reupload files

src/main/java/fr/xephi/authme/command/CommandArgumentDescription.java

@@ -0,0 +1,61 @@
+package fr.xephi.authme.command;
+
+/**
+ * Wrapper for the description of a command argument.
+ */
+public class CommandArgumentDescription {
+
+    /**
+     * Argument name (one-word description of the argument).
+     */
+    private final String name;
+    /**
+     * Argument description.
+     */
+    private final String description;
+    /**
+     * Defines whether the argument is optional.
+     */
+    private final boolean isOptional;
+
+    /**
+     * Constructor.
+     *
+     * @param name        The argument name.
+     * @param description The argument description.
+     * @param isOptional  True if the argument is optional, false otherwise.
+     */
+    public CommandArgumentDescription(String name, String description, boolean isOptional) {
+        this.name = name;
+        this.description = description;
+        this.isOptional = isOptional;
+    }
+
+    /**
+     * Get the argument name.
+     *
+     * @return Argument name.
+     */
+    public String getName() {
+        return this.name;
+    }
+
+    /**
+     * Get the argument description.
+     *
+     * @return Argument description.
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * Return whether the argument is optional.
+     *
+     * @return True if the argument is optional, false otherwise.
+     */
+    public boolean isOptional() {
+        return isOptional;
+    }
+
+}

src/main/java/fr/xephi/authme/command/CommandDescription.java

@@ -0,0 +1,294 @@
+package fr.xephi.authme.command;
+
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.util.StringUtils;
+import fr.xephi.authme.util.Utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Arrays.asList;
+
+/**
+ * Command description – defines which labels ("names") will lead to a command and points to the
+ * {@link ExecutableCommand} implementation that executes the logic of the command.
+ * <p>
+ * CommandDescription instances are built hierarchically: they have one parent, or {@code null} for base commands
+ * (main commands such as {@code /authme}), and may have multiple children extending the mapping of the parent: e.g. if
+ * {@code /authme} has a child whose label is {@code "register"}, then {@code /authme register} is the command that
+ * the child defines.
+ */
+@SuppressWarnings("checkstyle:FinalClass") // Justification: class is mocked in multiple tests
+public class CommandDescription {
+
+    /**
+     * Defines the labels to execute the command. For example, if labels are "register" and "r" and the parent is
+     * the command for "/authme", then both "/authme register" and "/authme r" will be handled by this command.
+     */
+    private List<String> labels;
+    /**
+     * Short description of the command.
+     */
+    private String description;
+    /**
+     * Detailed description of what the command does.
+     */
+    private String detailedDescription;
+    /**
+     * The class implementing the command described by this object.
+     */
+    private Class<? extends ExecutableCommand> executableCommand;
+    /**
+     * The parent command.
+     */
+    private CommandDescription parent;
+    /**
+     * The child commands that extend this command.
+     */
+    private List<CommandDescription> children = new ArrayList<>();
+    /**
+     * The arguments the command takes.
+     */
+    private List<CommandArgumentDescription> arguments;
+    /**
+     * Permission node required to execute this command.
+     */
+    private PermissionNode permission;
+
+    /**
+     * Private constructor.
+     * <p>
+     * Note for developers: Instances should be created with {@link CommandBuilder#register()} to be properly
+     * registered in the command tree.
+     *
+     * @param labels              command labels
+     * @param description         description of the command
+     * @param detailedDescription detailed command description
+     * @param executableCommand   class of the command implementation
+     * @param parent              parent command
+     * @param arguments           command arguments
+     * @param permission          permission node required to execute this command
+     */
+    private CommandDescription(List<String> labels, String description, String detailedDescription, 
+                               Class<? extends ExecutableCommand> executableCommand, CommandDescription parent,
+                               List<CommandArgumentDescription> arguments,  PermissionNode permission) {
+        this.labels = labels;
+        this.description = description;
+        this.detailedDescription = detailedDescription;
+        this.executableCommand = executableCommand;
+        this.parent = parent;
+        this.arguments = arguments;
+        this.permission = permission;
+    }
+
+    /**
+     * Return all relative labels of this command. For example, if this object describes {@code /authme register} and
+     * {@code /authme r}, then it will return a list with {@code register} and {@code r}. The parent label
+     * {@code authme} is not returned.
+     *
+     * @return All labels of the command description.
+     */
+    public List<String> getLabels() {
+        return labels;
+    }
+
+    /**
+     * Check whether this command description has the given label.
+     *
+     * @param commandLabel The label to check for.
+     *
+     * @return {@code true} if this command contains the given label, {@code false} otherwise.
+     */
+    public boolean hasLabel(String commandLabel) {
+        for (String label : labels) {
+            if (label.equalsIgnoreCase(commandLabel)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Return the {@link ExecutableCommand} class implementing this command.
+     *
+     * @return The executable command class
+     */
+    public Class<? extends ExecutableCommand> getExecutableCommand() {
+        return executableCommand;
+    }
+
+    /**
+     * Return the parent.
+     *
+     * @return The parent command, or null for base commands
+     */
+    public CommandDescription getParent() {
+        return parent;
+    }
+
+    /**
+     * Return the number of labels necessary to get to this command. This corresponds to the number of parents + 1.
+     *
+     * @return The number of labels, e.g. for "/authme abc def" the label count is 3
+     */
+    public int getLabelCount() {
+        if (parent == null) {
+            return 1;
+        }
+        return parent.getLabelCount() + 1;
+    }
+
+    /**
+     * Return all command children.
+     *
+     * @return Command children.
+     */
+    public List<CommandDescription> getChildren() {
+        return children;
+    }
+
+    /**
+     * Return all arguments the command takes.
+     *
+     * @return Command arguments.
+     */
+    public List<CommandArgumentDescription> getArguments() {
+        return arguments;
+    }
+
+    /**
+     * Return a short description of the command.
+     *
+     * @return Command description.
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * Return a detailed description of the command.
+     *
+     * @return Detailed description.
+     */
+    public String getDetailedDescription() {
+        return detailedDescription;
+    }
+
+    /**
+     * Return the permission node required to execute the command.
+     *
+     * @return The permission node, or null if none are required to execute the command.
+     */
+    public PermissionNode getPermission() {
+        return permission;
+    }
+
+    /**
+     * Return a builder instance to create a new command description.
+     *
+     * @return The builder
+     */
+    public static CommandBuilder builder() {
+        return new CommandBuilder();
+    }
+
+    /**
+     * Builder for initializing CommandDescription objects.
+     */
+    public static final class CommandBuilder {
+        private List<String> labels;
+        private String description;
+        private String detailedDescription;
+        private Class<? extends ExecutableCommand> executableCommand;
+        private CommandDescription parent;
+        private List<CommandArgumentDescription> arguments = new ArrayList<>();
+        private PermissionNode permission;
+
+        /**
+         * Build a CommandDescription and register it onto the parent if available.
+         *
+         * @return The generated CommandDescription object
+         */
+        public CommandDescription register() {
+            CommandDescription command = build();
+
+            if (command.parent != null) {
+                command.parent.children.add(command);
+            }
+            return command;
+        }
+
+        /**
+         * Build a CommandDescription (without registering it on the parent).
+         *
+         * @return The generated CommandDescription object
+         */
+        public CommandDescription build() {
+            checkArgument(!Utils.isCollectionEmpty(labels), "Labels may not be empty");
+            checkArgument(!StringUtils.isBlank(description), "Description may not be empty");
+            checkArgument(!StringUtils.isBlank(detailedDescription), "Detailed description may not be empty");
+            checkArgument(executableCommand != null, "Executable command must be set");
+            // parents and permissions may be null; arguments may be empty
+
+            return new CommandDescription(labels, description, detailedDescription, executableCommand,
+                                          parent, arguments, permission);
+        }
+
+        public CommandBuilder labels(List<String> labels) {
+            this.labels = labels;
+            return this;
+        }
+
+        public CommandBuilder labels(String... labels) {
+            return labels(asList(labels));
+        }
+
+        public CommandBuilder description(String description) {
+            this.description = description;
+            return this;
+        }
+
+        public CommandBuilder detailedDescription(String detailedDescription) {
+            this.detailedDescription = detailedDescription;
+            return this;
+        }
+
+        public CommandBuilder executableCommand(Class<? extends ExecutableCommand> executableCommand) {
+            this.executableCommand = executableCommand;
+            return this;
+        }
+
+        public CommandBuilder parent(CommandDescription parent) {
+            this.parent = parent;
+            return this;
+        }
+
+        /**
+         * Add an argument that the command description requires. This method can be called multiples times to add
+         * multiple arguments.
+         *
+         * @param label The label of the argument (single word name of the argument)
+         * @param description The description of the argument
+         * @param isOptional True if the argument is optional, false if it is mandatory
+         *
+         * @return The builder
+         */
+        public CommandBuilder withArgument(String label, String description, boolean isOptional) {
+            arguments.add(new CommandArgumentDescription(label, description, isOptional));
+            return this;
+        }
+
+        /**
+         * Add a permission node that a user must have to execute the command.
+         *
+         * @param permission The PermissionNode to add
+         * @return The builder
+         */
+        public CommandBuilder permission(PermissionNode permission) {
+            this.permission = permission;
+            return this;
+        }
+    }
+
+}

src/main/java/fr/xephi/authme/command/CommandHandler.java

@@ -0,0 +1,186 @@
+package fr.xephi.authme.command;
+
+import ch.jalu.injector.factory.Factory;
+import fr.xephi.authme.AuthMe;
+import fr.xephi.authme.command.help.HelpProvider;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.util.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * The AuthMe command handler, responsible for invoking the correct {@link ExecutableCommand} based on incoming
+ * command labels or for displaying a help message for unknown command labels.
+ */
+public class CommandHandler {
+
+    /**
+     * The threshold for suggesting a similar command. If the difference is below this value, we will
+     * ask the player whether he meant the similar command.
+     */
+    private static final double SUGGEST_COMMAND_THRESHOLD = 0.75;
+
+    private final CommandMapper commandMapper;
+    private final PermissionsManager permissionsManager;
+    private final Messages messages;
+    private final HelpProvider helpProvider;
+
+    /**
+     * Map with ExecutableCommand children. The key is the type of the value.
+     */
+    private Map<Class<? extends ExecutableCommand>, ExecutableCommand> commands = new HashMap<>();
+
+    @Inject
+    CommandHandler(Factory<ExecutableCommand> commandFactory, CommandMapper commandMapper,
+                   PermissionsManager permissionsManager, Messages messages, HelpProvider helpProvider) {
+        this.commandMapper = commandMapper;
+        this.permissionsManager = permissionsManager;
+        this.messages = messages;
+        this.helpProvider = helpProvider;
+        initializeCommands(commandFactory, commandMapper.getCommandClasses());
+    }
+
+    /**
+     * Map a command that was invoked to the proper {@link CommandDescription} or return a useful error
+     * message upon failure.
+     *
+     * @param sender             The command sender.
+     * @param bukkitCommandLabel The command label (Bukkit).
+     * @param bukkitArgs         The command arguments (Bukkit).
+     *
+     * @return True if the command was executed, false otherwise.
+     */
+    public boolean processCommand(CommandSender sender, String bukkitCommandLabel, String[] bukkitArgs) {
+        // Add the Bukkit command label to the front so we get a list like [authme, register, bobby, mysecret]
+        List<String> parts = skipEmptyArguments(bukkitArgs);
+        parts.add(0, bukkitCommandLabel);
+
+        FoundCommandResult result = commandMapper.mapPartsToCommand(sender, parts);
+        handleCommandResult(sender, result);
+        return !FoundResultStatus.MISSING_BASE_COMMAND.equals(result.getResultStatus());
+    }
+
+    /**
+     * Processes the given {@link FoundCommandResult} for the provided command sender.
+     *
+     * @param sender the command sender who executed the command
+     * @param result the command mapping result
+     */
+    private void handleCommandResult(CommandSender sender, FoundCommandResult result) {
+        switch (result.getResultStatus()) {
+            case SUCCESS:
+                executeCommand(sender, result);
+                break;
+            case MISSING_BASE_COMMAND:
+                sender.sendMessage(ChatColor.DARK_RED + "Failed to parse " + AuthMe.getPluginName() + " command!");
+                break;
+            case INCORRECT_ARGUMENTS:
+                sendImproperArgumentsMessage(sender, result);
+                break;
+            case UNKNOWN_LABEL:
+                sendUnknownCommandMessage(sender, result);
+                break;
+            case NO_PERMISSION:
+                messages.send(sender, MessageKey.NO_PERMISSION);
+                break;
+            default:
+                throw new IllegalStateException("Unknown result status '" + result.getResultStatus() + "'");
+        }
+    }
+
+    /**
+     * Initialize all required ExecutableCommand objects.
+     *
+     * @param commandFactory factory to create command objects
+     * @param commandClasses the classes to instantiate
+     */
+    private void initializeCommands(Factory<ExecutableCommand> commandFactory,
+                                    Set<Class<? extends ExecutableCommand>> commandClasses) {
+        for (Class<? extends ExecutableCommand> clazz : commandClasses) {
+            commands.put(clazz, commandFactory.newInstance(clazz));
+        }
+    }
+
+    /**
+     * Execute the command for the given command sender.
+     *
+     * @param sender The sender which initiated the command
+     * @param result The mapped result
+     */
+    private void executeCommand(CommandSender sender, FoundCommandResult result) {
+        ExecutableCommand executableCommand = commands.get(result.getCommandDescription().getExecutableCommand());
+        List<String> arguments = result.getArguments();
+        executableCommand.executeCommand(sender, arguments);
+    }
+
+    /**
+     * Skip all entries of the given array that are simply whitespace.
+     *
+     * @param args The array to process
+     * @return List of the items that are not empty
+     */
+    private static List<String> skipEmptyArguments(String[] args) {
+        List<String> cleanArguments = new ArrayList<>();
+        for (String argument : args) {
+            if (!StringUtils.isBlank(argument)) {
+                cleanArguments.add(argument);
+            }
+        }
+        return cleanArguments;
+    }
+
+    /**
+     * Show an "unknown command" message to the user and suggest an existing command if its similarity is within
+     * the defined threshold.
+     *
+     * @param sender The command sender
+     * @param result The command that was found during the mapping process
+     */
+    private static void sendUnknownCommandMessage(CommandSender sender, FoundCommandResult result) {
+        sender.sendMessage(ChatColor.DARK_RED + "Unknown command!");
+
+        // Show a command suggestion if available and the difference isn't too big
+        if (result.getDifference() <= SUGGEST_COMMAND_THRESHOLD && result.getCommandDescription() != null) {
+            sender.sendMessage(ChatColor.YELLOW + "Did you mean " + ChatColor.GOLD
+                + CommandUtils.constructCommandPath(result.getCommandDescription()) + ChatColor.YELLOW + "?");
+        }
+
+        sender.sendMessage(ChatColor.YELLOW + "Use the command " + ChatColor.GOLD + "/" + result.getLabels().get(0)
+            + " help" + ChatColor.YELLOW + " to view help.");
+    }
+
+    private void sendImproperArgumentsMessage(CommandSender sender, FoundCommandResult result) {
+        CommandDescription command = result.getCommandDescription();
+        if (!permissionsManager.hasPermission(sender, command.getPermission())) {
+            messages.send(sender, MessageKey.NO_PERMISSION);
+            return;
+        }
+
+        ExecutableCommand executableCommand = commands.get(command.getExecutableCommand());
+        MessageKey usageMessage = executableCommand.getArgumentsMismatchMessage();
+        if (usageMessage == null) {
+            showHelpForCommand(sender, result);
+        } else {
+            messages.send(sender, usageMessage);
+        }
+    }
+
+    private void showHelpForCommand(CommandSender sender, FoundCommandResult result) {
+        sender.sendMessage(ChatColor.DARK_RED + "Incorrect command arguments!");
+        helpProvider.outputHelp(sender, result, HelpProvider.SHOW_ARGUMENTS);
+
+        List<String> labels = result.getLabels();
+        String childLabel = labels.size() >= 2 ? labels.get(1) : "";
+        sender.sendMessage(ChatColor.GOLD + "Detailed help: " + ChatColor.WHITE
+            + "/" + labels.get(0) + " help " + childLabel);
+    }
+}

src/main/java/fr/xephi/authme/command/CommandInitializer.java

@@ -0,0 +1,652 @@
+package fr.xephi.authme.command;
+
+import com.google.common.collect.ImmutableList;
+import fr.xephi.authme.command.executable.HelpCommand;
+import fr.xephi.authme.command.executable.authme.AccountsCommand;
+import fr.xephi.authme.command.executable.authme.AuthMeCommand;
+import fr.xephi.authme.command.executable.authme.BackupCommand;
+import fr.xephi.authme.command.executable.authme.ChangePasswordAdminCommand;
+import fr.xephi.authme.command.executable.authme.ConverterCommand;
+import fr.xephi.authme.command.executable.authme.FirstSpawnCommand;
+import fr.xephi.authme.command.executable.authme.ForceLoginCommand;
+import fr.xephi.authme.command.executable.authme.GetEmailCommand;
+import fr.xephi.authme.command.executable.authme.GetIpCommand;
+import fr.xephi.authme.command.executable.authme.LastLoginCommand;
+import fr.xephi.authme.command.executable.authme.PurgeBannedPlayersCommand;
+import fr.xephi.authme.command.executable.authme.PurgeCommand;
+import fr.xephi.authme.command.executable.authme.PurgeLastPositionCommand;
+import fr.xephi.authme.command.executable.authme.PurgePlayerCommand;
+import fr.xephi.authme.command.executable.authme.RecentPlayersCommand;
+import fr.xephi.authme.command.executable.authme.RegisterAdminCommand;
+import fr.xephi.authme.command.executable.authme.ReloadCommand;
+import fr.xephi.authme.command.executable.authme.SetEmailCommand;
+import fr.xephi.authme.command.executable.authme.SetFirstSpawnCommand;
+import fr.xephi.authme.command.executable.authme.SetSpawnCommand;
+import fr.xephi.authme.command.executable.authme.SpawnCommand;
+import fr.xephi.authme.command.executable.authme.SwitchAntiBotCommand;
+import fr.xephi.authme.command.executable.authme.TotpDisableAdminCommand;
+import fr.xephi.authme.command.executable.authme.TotpViewStatusCommand;
+import fr.xephi.authme.command.executable.authme.UnregisterAdminCommand;
+import fr.xephi.authme.command.executable.authme.UpdateHelpMessagesCommand;
+import fr.xephi.authme.command.executable.authme.VersionCommand;
+import fr.xephi.authme.command.executable.authme.debug.DebugCommand;
+import fr.xephi.authme.command.executable.captcha.CaptchaCommand;
+import fr.xephi.authme.command.executable.changepassword.ChangePasswordCommand;
+import fr.xephi.authme.command.executable.email.AddEmailCommand;
+import fr.xephi.authme.command.executable.email.ChangeEmailCommand;
+import fr.xephi.authme.command.executable.email.EmailBaseCommand;
+import fr.xephi.authme.command.executable.email.EmailSetPasswordCommand;
+import fr.xephi.authme.command.executable.email.ProcessCodeCommand;
+import fr.xephi.authme.command.executable.email.RecoverEmailCommand;
+import fr.xephi.authme.command.executable.email.ShowEmailCommand;
+import fr.xephi.authme.command.executable.login.LoginCommand;
+import fr.xephi.authme.command.executable.logout.LogoutCommand;
+import fr.xephi.authme.command.executable.register.RegisterCommand;
+import fr.xephi.authme.command.executable.totp.AddTotpCommand;
+import fr.xephi.authme.command.executable.totp.ConfirmTotpCommand;
+import fr.xephi.authme.command.executable.totp.RemoveTotpCommand;
+import fr.xephi.authme.command.executable.totp.TotpBaseCommand;
+import fr.xephi.authme.command.executable.totp.TotpCodeCommand;
+import fr.xephi.authme.command.executable.unregister.UnregisterCommand;
+import fr.xephi.authme.command.executable.verification.VerificationCommand;
+import fr.xephi.authme.permission.AdminPermission;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PlayerPermission;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Initializes all available AuthMe commands.
+ */
+public class CommandInitializer {
+
+    private static final boolean OPTIONAL = true;
+    private static final boolean MANDATORY = false;
+
+    private List<CommandDescription> commands;
+
+    public CommandInitializer() {
+        buildCommands();
+    }
+
+    /**
+     * Returns the description of all AuthMe commands.
+     *
+     * @return the command descriptions
+     */
+    public List<CommandDescription> getCommands() {
+        return commands;
+    }
+
+    /**
+     * Builds the command description objects for all available AuthMe commands.
+     */
+    private void buildCommands() {
+        // Register /authme and /email commands
+        CommandDescription authMeBase = buildAuthMeBaseCommand();
+        CommandDescription emailBase = buildEmailBaseCommand();
+
+        // Register the base login command
+        CommandDescription loginBase = CommandDescription.builder()
+            .parent(null)
+            .labels("login", "l", "log")
+            .description("Login command")
+            .detailedDescription("Command to log in using AuthMeReloaded.")
+            .withArgument("password", "Login password", MANDATORY)
+            .permission(PlayerPermission.LOGIN)
+            .executableCommand(LoginCommand.class)
+            .register();
+
+        // Register the base logout command
+        CommandDescription logoutBase = CommandDescription.builder()
+            .parent(null)
+            .labels("logout")
+            .description("Logout command")
+            .detailedDescription("Command to logout using AuthMeReloaded.")
+            .permission(PlayerPermission.LOGOUT)
+            .executableCommand(LogoutCommand.class)
+            .register();
+
+        // Register the base register command
+        CommandDescription registerBase = CommandDescription.builder()
+            .parent(null)
+            .labels("register", "reg")
+            .description("Register an account")
+            .detailedDescription("Command to register using AuthMeReloaded.")
+            .withArgument("password", "Password", OPTIONAL)
+            .withArgument("verifyPassword", "Verify password", OPTIONAL)
+            .permission(PlayerPermission.REGISTER)
+            .executableCommand(RegisterCommand.class)
+            .register();
+
+        // Register the base unregister command
+        CommandDescription unregisterBase = CommandDescription.builder()
+            .parent(null)
+            .labels("unregister", "unreg")
+            .description("Unregister an account")
+            .detailedDescription("Command to unregister using AuthMeReloaded.")
+            .withArgument("password", "Password", MANDATORY)
+            .permission(PlayerPermission.UNREGISTER)
+            .executableCommand(UnregisterCommand.class)
+            .register();
+
+        // Register the base changepassword command
+        CommandDescription changePasswordBase = CommandDescription.builder()
+            .parent(null)
+            .labels("changepassword", "changepass", "cp")
+            .description("Change password of an account")
+            .detailedDescription("Command to change your password using AuthMeReloaded.")
+            .withArgument("oldPassword", "Old password", MANDATORY)
+            .withArgument("newPassword", "New password", MANDATORY)
+            .permission(PlayerPermission.CHANGE_PASSWORD)
+            .executableCommand(ChangePasswordCommand.class)
+            .register();
+
+        // Create totp base command
+        CommandDescription totpBase = buildTotpBaseCommand();
+
+        // Register the base captcha command
+        CommandDescription captchaBase = CommandDescription.builder()
+            .parent(null)
+            .labels("captcha")
+            .description("Captcha command")
+            .detailedDescription("Captcha command for AuthMeReloaded.")
+            .withArgument("captcha", "The Captcha", MANDATORY)
+            .permission(PlayerPermission.CAPTCHA)
+            .executableCommand(CaptchaCommand.class)
+            .register();
+
+        // Register the base verification code command
+        CommandDescription verificationBase = CommandDescription.builder()
+            .parent(null)
+            .labels("verification")
+            .description("Verification command")
+            .detailedDescription("Command to complete the verification process for AuthMeReloaded.")
+            .withArgument("code", "The code", MANDATORY)
+            .permission(PlayerPermission.VERIFICATION_CODE)
+            .executableCommand(VerificationCommand.class)
+            .register();
+
+        List<CommandDescription> baseCommands = ImmutableList.of(authMeBase, emailBase, loginBase, logoutBase,
+            registerBase, unregisterBase, changePasswordBase, totpBase, captchaBase, verificationBase);
+
+        setHelpOnAllBases(baseCommands);
+        commands = baseCommands;
+    }
+
+    /**
+     * Creates a command description object for {@code /authme} including its children.
+     *
+     * @return the authme base command description
+     */
+    private CommandDescription buildAuthMeBaseCommand() {
+        // Register the base AuthMe Reloaded command
+        CommandDescription authmeBase = CommandDescription.builder()
+            .labels("authme")
+            .description("AuthMe op commands")
+            .detailedDescription("The main AuthMeReloaded command. The root for all admin commands.")
+            .executableCommand(AuthMeCommand.class)
+            .register();
+
+        // Register the register command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("register", "reg", "r")
+            .description("Register a player")
+            .detailedDescription("Register the specified player with the specified password.")
+            .withArgument("player", "Player name", MANDATORY)
+            .withArgument("password", "Password", MANDATORY)
+            .permission(AdminPermission.REGISTER)
+            .executableCommand(RegisterAdminCommand.class)
+            .register();
+
+        // Register the unregister command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("unregister", "unreg", "unr")
+            .description("Unregister a player")
+            .detailedDescription("Unregister the specified player.")
+            .withArgument("player", "Player name", MANDATORY)
+            .permission(AdminPermission.UNREGISTER)
+            .executableCommand(UnregisterAdminCommand.class)
+            .register();
+
+        // Register the forcelogin command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("forcelogin", "login")
+            .description("Enforce login player")
+            .detailedDescription("Enforce the specified player to login.")
+            .withArgument("player", "Online player name", OPTIONAL)
+            .permission(AdminPermission.FORCE_LOGIN)
+            .executableCommand(ForceLoginCommand.class)
+            .register();
+
+        // Register the changepassword command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("password", "changepassword", "changepass", "cp")
+            .description("Change a player's password")
+            .detailedDescription("Change the password of a player.")
+            .withArgument("player", "Player name", MANDATORY)
+            .withArgument("pwd", "New password", MANDATORY)
+            .permission(AdminPermission.CHANGE_PASSWORD)
+            .executableCommand(ChangePasswordAdminCommand.class)
+            .register();
+
+        // Register the last login command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("lastlogin", "ll")
+            .description("Player's last login")
+            .detailedDescription("View the date of the specified players last login.")
+            .withArgument("player", "Player name", OPTIONAL)
+            .permission(AdminPermission.LAST_LOGIN)
+            .executableCommand(LastLoginCommand.class)
+            .register();
+
+        // Register the accounts command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("accounts", "account")
+            .description("Display player accounts")
+            .detailedDescription("Display all accounts of a player by his player name or IP.")
+            .withArgument("player", "Player name or IP", OPTIONAL)
+            .permission(AdminPermission.ACCOUNTS)
+            .executableCommand(AccountsCommand.class)
+            .register();
+
+        // Register the getemail command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("email", "mail", "getemail", "getmail")
+            .description("Display player's email")
+            .detailedDescription("Display the email address of the specified player if set.")
+            .withArgument("player", "Player name", OPTIONAL)
+            .permission(AdminPermission.GET_EMAIL)
+            .executableCommand(GetEmailCommand.class)
+            .register();
+
+        // Register the setemail command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("setemail", "setmail", "chgemail", "chgmail")
+            .description("Change player's email")
+            .detailedDescription("Change the email address of the specified player.")
+            .withArgument("player", "Player name", MANDATORY)
+            .withArgument("email", "Player email", MANDATORY)
+            .permission(AdminPermission.CHANGE_EMAIL)
+            .executableCommand(SetEmailCommand.class)
+            .register();
+
+        // Register the getip command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("getip", "ip")
+            .description("Get player's IP")
+            .detailedDescription("Get the IP address of the specified online player.")
+            .withArgument("player", "Player name", MANDATORY)
+            .permission(AdminPermission.GET_IP)
+            .executableCommand(GetIpCommand.class)
+            .register();
+
+        // Register totp command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("totp", "2fa")
+            .description("See if a player has enabled TOTP")
+            .detailedDescription("Returns whether the specified player has enabled two-factor authentication.")
+            .withArgument("player", "Player name", MANDATORY)
+            .permission(AdminPermission.VIEW_TOTP_STATUS)
+            .executableCommand(TotpViewStatusCommand.class)
+            .register();
+
+        // Register disable totp command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("disabletotp", "disable2fa", "deletetotp", "delete2fa")
+            .description("Delete TOTP token of a player")
+            .detailedDescription("Disable two-factor authentication for a player.")
+            .withArgument("player", "Player name", MANDATORY)
+            .permission(AdminPermission.DISABLE_TOTP)
+            .executableCommand(TotpDisableAdminCommand.class)
+            .register();
+
+        // Register the spawn command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("spawn", "home")
+            .description("Teleport to spawn")
+            .detailedDescription("Teleport to the spawn.")
+            .permission(AdminPermission.SPAWN)
+            .executableCommand(SpawnCommand.class)
+            .register();
+
+        // Register the setspawn command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("setspawn", "chgspawn")
+            .description("Change the spawn")
+            .detailedDescription("Change the player's spawn to your current position.")
+            .permission(AdminPermission.SET_SPAWN)
+            .executableCommand(SetSpawnCommand.class)
+            .register();
+
+        // Register the firstspawn command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("firstspawn", "firsthome")
+            .description("Teleport to first spawn")
+            .detailedDescription("Teleport to the first spawn.")
+            .permission(AdminPermission.FIRST_SPAWN)
+            .executableCommand(FirstSpawnCommand.class)
+            .register();
+
+        // Register the setfirstspawn command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("setfirstspawn", "chgfirstspawn")
+            .description("Change the first spawn")
+            .detailedDescription("Change the first player's spawn to your current position.")
+            .permission(AdminPermission.SET_FIRST_SPAWN)
+            .executableCommand(SetFirstSpawnCommand.class)
+            .register();
+
+        // Register the purge command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("purge", "delete")
+            .description("Purge old data")
+            .detailedDescription("Purge old AuthMeReloaded data longer than the specified number of days ago.")
+            .withArgument("days", "Number of days", MANDATORY)
+            .permission(AdminPermission.PURGE)
+            .executableCommand(PurgeCommand.class)
+            .register();
+
+        // Purge player command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("purgeplayer")
+            .description("Purges the data of one player")
+            .detailedDescription("Purges data of the given player.")
+            .withArgument("player", "The player to purge", MANDATORY)
+            .withArgument("options", "'force' to run without checking if player is registered", OPTIONAL)
+            .permission(AdminPermission.PURGE_PLAYER)
+            .executableCommand(PurgePlayerCommand.class)
+            .register();
+
+        // Backup command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("backup")
+            .description("Perform a backup")
+            .detailedDescription("Creates a backup of the registered users.")
+            .permission(AdminPermission.BACKUP)
+            .executableCommand(BackupCommand.class)
+            .register();
+
+        // Register the purgelastposition command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("resetpos", "purgelastposition", "purgelastpos", "resetposition",
+                "resetlastposition", "resetlastpos")
+            .description("Purge player's last position")
+            .detailedDescription("Purge the last know position of the specified player or all of them.")
+            .withArgument("player/*", "Player name or * for all players", MANDATORY)
+            .permission(AdminPermission.PURGE_LAST_POSITION)
+            .executableCommand(PurgeLastPositionCommand.class)
+            .register();
+
+        // Register the purgebannedplayers command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("purgebannedplayers", "purgebannedplayer", "deletebannedplayers", "deletebannedplayer")
+            .description("Purge banned players data")
+            .detailedDescription("Purge all AuthMeReloaded data for banned players.")
+            .permission(AdminPermission.PURGE_BANNED_PLAYERS)
+            .executableCommand(PurgeBannedPlayersCommand.class)
+            .register();
+
+        // Register the switchantibot command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("switchantibot", "toggleantibot", "antibot")
+            .description("Switch AntiBot mode")
+            .detailedDescription("Switch or toggle the AntiBot mode to the specified state.")
+            .withArgument("mode", "ON / OFF", OPTIONAL)
+            .permission(AdminPermission.SWITCH_ANTIBOT)
+            .executableCommand(SwitchAntiBotCommand.class)
+            .register();
+
+        // Register the reload command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("reload", "rld")
+            .description("Reload plugin")
+            .detailedDescription("Reload the AuthMeReloaded plugin.")
+            .permission(AdminPermission.RELOAD)
+            .executableCommand(ReloadCommand.class)
+            .register();
+
+        // Register the version command
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("version", "ver", "v", "about", "info")
+            .description("Version info")
+            .detailedDescription("Show detailed information about the installed AuthMeReloaded version, the "
+                + "developers, contributors, and license.")
+            .executableCommand(VersionCommand.class)
+            .register();
+
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("converter", "convert", "conv")
+            .description("Converter command")
+            .detailedDescription("Converter command for AuthMeReloaded.")
+            .withArgument("job", "Conversion job: xauth / crazylogin / rakamak / "
+                + "royalauth / vauth / sqliteToSql / mysqlToSqlite / loginsecurity", OPTIONAL)
+            .permission(AdminPermission.CONVERTER)
+            .executableCommand(ConverterCommand.class)
+            .register();
+
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("messages", "msg")
+            .description("Add missing help messages")
+            .detailedDescription("Adds missing texts to the current help messages file.")
+            .permission(AdminPermission.UPDATE_MESSAGES)
+            .executableCommand(UpdateHelpMessagesCommand.class)
+            .register();
+
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("recent")
+            .description("See players who have recently logged in")
+            .detailedDescription("Shows the last players that have logged in.")
+            .permission(AdminPermission.SEE_RECENT_PLAYERS)
+            .executableCommand(RecentPlayersCommand.class)
+            .register();
+
+        CommandDescription.builder()
+            .parent(authmeBase)
+            .labels("debug", "dbg")
+            .description("Debug features")
+            .detailedDescription("Allows various operations for debugging.")
+            .withArgument("child", "The child to execute", OPTIONAL)
+            .withArgument("arg", "argument (depends on debug section)", OPTIONAL)
+            .withArgument("arg", "argument (depends on debug section)", OPTIONAL)
+            .permission(DebugSectionPermissions.DEBUG_COMMAND)
+            .executableCommand(DebugCommand.class)
+            .register();
+
+        return authmeBase;
+    }
+
+    /**
+     * Creates a command description for {@code /email} including its children.
+     *
+     * @return the email base command description
+     */
+    private CommandDescription buildEmailBaseCommand() {
+        // Register the base Email command
+        CommandDescription emailBase = CommandDescription.builder()
+            .parent(null)
+            .labels("email")
+            .description("Add email or recover password")
+            .detailedDescription("The AuthMeReloaded email command base.")
+            .executableCommand(EmailBaseCommand.class)
+            .register();
+
+        // Register the show command
+        CommandDescription.builder()
+            .parent(emailBase)
+            .labels("show", "myemail")
+            .description("Show Email")
+            .detailedDescription("Show your current email address.")
+            .permission(PlayerPermission.SEE_EMAIL)
+            .executableCommand(ShowEmailCommand.class)
+            .register();
+
+        // Register the add command
+        CommandDescription.builder()
+            .parent(emailBase)
+            .labels("add", "addemail", "addmail")
+            .description("Add Email")
+            .detailedDescription("Add a new email address to your account.")
+            .withArgument("email", "Email address", MANDATORY)
+            .withArgument("verifyEmail", "Email address verification", MANDATORY)
+            .permission(PlayerPermission.ADD_EMAIL)
+            .executableCommand(AddEmailCommand.class)
+            .register();
+
+        // Register the change command
+        CommandDescription.builder()
+            .parent(emailBase)
+            .labels("change", "changeemail", "changemail")
+            .description("Change Email")
+            .detailedDescription("Change an email address of your account.")
+            .withArgument("oldEmail", "Old email address", MANDATORY)
+            .withArgument("newEmail", "New email address", MANDATORY)
+            .permission(PlayerPermission.CHANGE_EMAIL)
+            .executableCommand(ChangeEmailCommand.class)
+            .register();
+
+        // Register the recover command
+        CommandDescription.builder()
+            .parent(emailBase)
+            .labels("recover", "recovery", "recoveremail", "recovermail")
+            .description("Recover password using email")
+            .detailedDescription("Recover your account using an Email address by sending a mail containing "
+                + "a new password.")
+            .withArgument("email", "Email address", MANDATORY)
+            .permission(PlayerPermission.RECOVER_EMAIL)
+            .executableCommand(RecoverEmailCommand.class)
+            .register();
+
+        // Register the process recovery code command
+        CommandDescription.builder()
+            .parent(emailBase)
+            .labels("code")
+            .description("Submit code to recover password")
+            .detailedDescription("Recover your account by submitting a code delivered to your email.")
+            .withArgument("code", "Recovery code", MANDATORY)
+            .permission(PlayerPermission.RECOVER_EMAIL)
+            .executableCommand(ProcessCodeCommand.class)
+            .register();
+
+        // Register the change password after recovery command
+        CommandDescription.builder()
+            .parent(emailBase)
+            .labels("setpassword")
+            .description("Set new password after recovery")
+            .detailedDescription("Set a new password after successfully recovering your account.")
+            .withArgument("password", "New password", MANDATORY)
+            .permission(PlayerPermission.RECOVER_EMAIL)
+            .executableCommand(EmailSetPasswordCommand.class)
+            .register();
+
+        return emailBase;
+    }
+
+    /**
+     * Creates a command description object for {@code /totp} including its children.
+     *
+     * @return the totp base command description
+     */
+    private CommandDescription buildTotpBaseCommand() {
+        // Register the base totp command
+        CommandDescription totpBase = CommandDescription.builder()
+            .parent(null)
+            .labels("totp", "2fa")
+            .description("TOTP commands")
+            .detailedDescription("Performs actions related to two-factor authentication.")
+            .executableCommand(TotpBaseCommand.class)
+            .register();
+
+        // Register the base totp code
+        CommandDescription.builder()
+            .parent(totpBase)
+            .labels("code", "c")
+            .description("Command for logging in")
+            .detailedDescription("Processes the two-factor authentication code during login.")
+            .withArgument("code", "The TOTP code to use to log in", MANDATORY)
+            .executableCommand(TotpCodeCommand.class)
+            .register();
+
+        // Register totp add
+        CommandDescription.builder()
+            .parent(totpBase)
+            .labels("add")
+            .description("Enables TOTP")
+            .detailedDescription("Enables two-factor authentication for your account.")
+            .permission(PlayerPermission.ENABLE_TWO_FACTOR_AUTH)
+            .executableCommand(AddTotpCommand.class)
+            .register();
+
+        // Register totp confirm
+        CommandDescription.builder()
+            .parent(totpBase)
+            .labels("confirm")
+            .description("Enables TOTP after successful code")
+            .detailedDescription("Saves the generated TOTP secret after confirmation.")
+            .withArgument("code", "Code from the given secret from /totp add", MANDATORY)
+            .permission(PlayerPermission.ENABLE_TWO_FACTOR_AUTH)
+            .executableCommand(ConfirmTotpCommand.class)
+            .register();
+
+        // Register totp remove
+        CommandDescription.builder()
+            .parent(totpBase)
+            .labels("remove")
+            .description("Removes TOTP")
+            .detailedDescription("Disables two-factor authentication for your account.")
+            .withArgument("code", "Current 2FA code", MANDATORY)
+            .permission(PlayerPermission.DISABLE_TWO_FACTOR_AUTH)
+            .executableCommand(RemoveTotpCommand.class)
+            .register();
+
+        return totpBase;
+    }
+
+    /**
+     * Sets the help command on all base commands, e.g. to register /authme help or /register help.
+     *
+     * @param commands the list of base commands to register a help child command on
+     */
+    private void setHelpOnAllBases(Collection<CommandDescription> commands) {
+        final List<String> helpCommandLabels = Arrays.asList("help", "hlp", "h", "sos", "?");
+
+        for (CommandDescription base : commands) {
+            CommandDescription.builder()
+                .parent(base)
+                .labels(helpCommandLabels)
+                .description("View help")
+                .detailedDescription("View detailed help for /" + base.getLabels().get(0) + " commands.")
+                .withArgument("query", "The command or query to view help for.", OPTIONAL)
+                .executableCommand(HelpCommand.class)
+                .register();
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/CommandMapper.java

@@ -0,0 +1,207 @@
+package fr.xephi.authme.command;
+
+import fr.xephi.authme.command.executable.HelpCommand;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.util.StringUtils;
+import fr.xephi.authme.util.Utils;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+import static fr.xephi.authme.command.FoundResultStatus.INCORRECT_ARGUMENTS;
+import static fr.xephi.authme.command.FoundResultStatus.MISSING_BASE_COMMAND;
+import static fr.xephi.authme.command.FoundResultStatus.UNKNOWN_LABEL;
+
+/**
+ * Maps incoming command parts to the correct {@link CommandDescription}.
+ */
+public class CommandMapper {
+
+    /**
+     * The class of the help command, to which the base label should also be passed in the arguments.
+     */
+    private static final Class<? extends ExecutableCommand> HELP_COMMAND_CLASS = HelpCommand.class;
+
+    private final Collection<CommandDescription> baseCommands;
+    private final PermissionsManager permissionsManager;
+
+    @Inject
+    public CommandMapper(CommandInitializer commandInitializer, PermissionsManager permissionsManager) {
+        this.baseCommands = commandInitializer.getCommands();
+        this.permissionsManager = permissionsManager;
+    }
+
+
+    /**
+     * Map incoming command parts to a command. This processes all parts and distinguishes the labels from arguments.
+     *
+     * @param sender The command sender (null if none applicable)
+     * @param parts The parts to map to commands and arguments
+     * @return The generated {@link FoundCommandResult}
+     */
+    public FoundCommandResult mapPartsToCommand(CommandSender sender, List<String> parts) {
+        if (Utils.isCollectionEmpty(parts)) {
+            return new FoundCommandResult(null, parts, null, 0.0, MISSING_BASE_COMMAND);
+        }
+
+        CommandDescription base = getBaseCommand(parts.get(0));
+        if (base == null) {
+            return new FoundCommandResult(null, parts, null, 0.0, MISSING_BASE_COMMAND);
+        }
+
+        // Prefer labels: /register help goes to "Help command", not "Register command" with argument 'help'
+        List<String> remainingParts = parts.subList(1, parts.size());
+        CommandDescription childCommand = getSuitableChild(base, remainingParts);
+        if (childCommand != null) {
+            FoundResultStatus status = getPermissionAwareStatus(sender, childCommand);
+            FoundCommandResult result = new FoundCommandResult(
+                childCommand, parts.subList(0, 2), parts.subList(2, parts.size()), 0.0, status);
+            return transformResultForHelp(result);
+        } else if (hasSuitableArgumentCount(base, remainingParts.size())) {
+            FoundResultStatus status = getPermissionAwareStatus(sender, base);
+            return new FoundCommandResult(base, parts.subList(0, 1), parts.subList(1, parts.size()), 0.0, status);
+        }
+
+        return getCommandWithSmallestDifference(base, parts);
+    }
+
+    /**
+     * Return all {@link ExecutableCommand} classes referenced in {@link CommandDescription} objects.
+     *
+     * @return all classes
+     * @see CommandInitializer#getCommands
+     */
+    public Set<Class<? extends ExecutableCommand>> getCommandClasses() {
+        Set<Class<? extends ExecutableCommand>> classes = new HashSet<>(50);
+        for (CommandDescription command : baseCommands) {
+            classes.add(command.getExecutableCommand());
+            for (CommandDescription child : command.getChildren()) {
+                classes.add(child.getExecutableCommand());
+            }
+        }
+        return classes;
+    }
+
+    /**
+     * Return the command whose label matches the given parts the best. This method is called when
+     * a successful mapping could not be performed.
+     *
+     * @param base the base command
+     * @param parts the command parts
+     * @return the closest result
+     */
+    private static FoundCommandResult getCommandWithSmallestDifference(CommandDescription base, List<String> parts) {
+        // Return the base command with incorrect arg count error if we only have one part
+        if (parts.size() <= 1) {
+            return new FoundCommandResult(base, parts, new ArrayList<>(), 0.0, INCORRECT_ARGUMENTS);
+        }
+
+        final String childLabel = parts.get(1);
+        double minDifference = Double.POSITIVE_INFINITY;
+        CommandDescription closestCommand = null;
+
+        for (CommandDescription child : base.getChildren()) {
+            double difference = getLabelDifference(child, childLabel);
+            if (difference < minDifference) {
+                minDifference = difference;
+                closestCommand = child;
+            }
+        }
+
+        // base command may have no children, in which case we return the base command with incorrect arguments error
+        if (closestCommand == null) {
+            return new FoundCommandResult(
+                base, parts.subList(0, 1), parts.subList(1, parts.size()), 0.0, INCORRECT_ARGUMENTS);
+        }
+
+        FoundResultStatus status = (minDifference == 0.0) ? INCORRECT_ARGUMENTS : UNKNOWN_LABEL;
+        final int partsSize = parts.size();
+        List<String> labels = parts.subList(0, Math.min(closestCommand.getLabelCount(), partsSize));
+        List<String> arguments = (labels.size() == partsSize)
+            ? new ArrayList<>()
+            : parts.subList(labels.size(), partsSize);
+
+        return new FoundCommandResult(closestCommand, labels, arguments, minDifference, status);
+    }
+
+    private CommandDescription getBaseCommand(String label) {
+        String baseLabel = label.toLowerCase(Locale.ROOT);
+        if (baseLabel.startsWith("authme:")) {
+            baseLabel = baseLabel.substring("authme:".length());
+        }
+        for (CommandDescription command : baseCommands) {
+            if (command.hasLabel(baseLabel)) {
+                return command;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Return a child from a base command if the label and the argument count match.
+     *
+     * @param baseCommand The base command whose children should be checked
+     * @param parts The command parts received from the invocation; the first item is the potential label and any
+     *              other items are command arguments. The first initial part that led to the base command should not
+     *              be present.
+     *
+     * @return A command if there was a complete match (including proper argument count), null otherwise
+     */
+    private static CommandDescription getSuitableChild(CommandDescription baseCommand, List<String> parts) {
+        if (Utils.isCollectionEmpty(parts)) {
+            return null;
+        }
+
+        final String label = parts.get(0).toLowerCase(Locale.ROOT);
+        final int argumentCount = parts.size() - 1;
+
+        for (CommandDescription child : baseCommand.getChildren()) {
+            if (child.hasLabel(label) && hasSuitableArgumentCount(child, argumentCount)) {
+                return child;
+            }
+        }
+        return null;
+    }
+
+    private static FoundCommandResult transformResultForHelp(FoundCommandResult result) {
+        if (result.getCommandDescription() != null
+            && HELP_COMMAND_CLASS == result.getCommandDescription().getExecutableCommand()) {
+            // For "/authme help register" we have labels = [authme, help] and arguments = [register]
+            // But for the help command we want labels = [authme, help] and arguments = [authme, register],
+            // so we can use the arguments as the labels to the command to show help for
+            List<String> arguments = new ArrayList<>(result.getArguments());
+            arguments.add(0, result.getLabels().get(0));
+            return new FoundCommandResult(result.getCommandDescription(), result.getLabels(),
+                arguments, result.getDifference(), result.getResultStatus());
+        }
+        return result;
+    }
+
+    private FoundResultStatus getPermissionAwareStatus(CommandSender sender, CommandDescription command) {
+        if (sender != null && !permissionsManager.hasPermission(sender, command.getPermission())) {
+            return FoundResultStatus.NO_PERMISSION;
+        }
+        return FoundResultStatus.SUCCESS;
+    }
+
+    private static boolean hasSuitableArgumentCount(CommandDescription command, int argumentCount) {
+        int minArgs = CommandUtils.getMinNumberOfArguments(command);
+        int maxArgs = CommandUtils.getMaxNumberOfArguments(command);
+
+        return argumentCount >= minArgs && argumentCount <= maxArgs;
+    }
+
+    private static double getLabelDifference(CommandDescription command, String givenLabel) {
+        return command.getLabels().stream()
+            .map(label -> StringUtils.getDifference(label, givenLabel))
+            .min(Double::compareTo)
+            .orElseThrow(() -> new IllegalStateException("Command does not have any labels set"));
+    }
+
+}

src/main/java/fr/xephi/authme/command/CommandUtils.java

@@ -0,0 +1,109 @@
+package fr.xephi.authme.command;
+
+import com.google.common.collect.Lists;
+import org.bukkit.ChatColor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility functions for {@link CommandDescription} objects.
+ */
+public final class CommandUtils {
+
+    private CommandUtils() {
+    }
+
+    /**
+     * Returns the minimum number of arguments required for running the command (= number of mandatory arguments).
+     *
+     * @param command the command to process
+     * @return min number of arguments required by the command
+     */
+    public static int getMinNumberOfArguments(CommandDescription command) {
+        int mandatoryArguments = 0;
+        for (CommandArgumentDescription argument : command.getArguments()) {
+            if (!argument.isOptional()) {
+                ++mandatoryArguments;
+            }
+        }
+        return mandatoryArguments;
+    }
+
+    /**
+     * Returns the maximum number of arguments the command accepts.
+     *
+     * @param command the command to process
+     * @return max number of arguments that may be passed to the command
+     */
+    public static int getMaxNumberOfArguments(CommandDescription command) {
+        return command.getArguments().size();
+    }
+
+    /**
+     * Constructs a hierarchical list of commands for the given command. The commands are in order:
+     * the parents of the given command precede the provided command. For example, given the command
+     * for {@code /authme register}, a list with {@code [{authme}, {authme register}]} is returned.
+     *
+     * @param command the command to build a parent list for
+     * @return the parent list
+     */
+    public static List<CommandDescription> constructParentList(CommandDescription command) {
+        List<CommandDescription> commands = new ArrayList<>();
+        CommandDescription currentCommand = command;
+        while (currentCommand != null) {
+            commands.add(currentCommand);
+            currentCommand = currentCommand.getParent();
+        }
+        return Lists.reverse(commands);
+    }
+
+    /**
+     * Returns a textual representation of the command, e.g. {@code /authme register}.
+     *
+     * @param command the command to create the path for
+     * @return the command string
+     */
+    public static String constructCommandPath(CommandDescription command) {
+        StringBuilder sb = new StringBuilder();
+        String prefix = "/";
+        for (CommandDescription ancestor : constructParentList(command)) {
+            sb.append(prefix).append(ancestor.getLabels().get(0));
+            prefix = " ";
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Constructs a command path with color formatting, based on the supplied labels. This includes
+     * the command's arguments, as defined in the provided command description. The list of labels
+     * must contain all labels to be used.
+     *
+     * @param command the command to read arguments from
+     * @param correctLabels the labels to use (must be complete)
+     * @return formatted command syntax incl. arguments
+     */
+    public static String buildSyntax(CommandDescription command, List<String> correctLabels) {
+        String commandSyntax = ChatColor.WHITE + "/" + correctLabels.get(0) + ChatColor.YELLOW;
+        for (int i = 1; i < correctLabels.size(); ++i) {
+            commandSyntax += " " + correctLabels.get(i);
+        }
+        for (CommandArgumentDescription argument : command.getArguments()) {
+            commandSyntax += " " + formatArgument(argument);
+        }
+        return commandSyntax;
+    }
+
+    /**
+     * Formats a command argument with the proper type of brackets.
+     *
+     * @param argument the argument to format
+     * @return the formatted argument
+     */
+    public static String formatArgument(CommandArgumentDescription argument) {
+        if (argument.isOptional()) {
+            return "[" + argument.getName() + "]";
+        }
+        return "<" + argument.getName() + ">";
+    }
+}

src/main/java/fr/xephi/authme/command/ExecutableCommand.java

@@ -0,0 +1,31 @@
+package fr.xephi.authme.command;
+
+import fr.xephi.authme.message.MessageKey;
+import org.bukkit.command.CommandSender;
+
+import java.util.List;
+
+/**
+ * Base class for AuthMe commands that can be executed.
+ */
+public interface ExecutableCommand {
+
+    /**
+     * Executes the command with the given arguments.
+     *
+     * @param sender     the command sender (initiator of the command)
+     * @param arguments  the arguments
+     */
+    void executeCommand(CommandSender sender, List<String> arguments);
+
+    /**
+     * Returns the message to show to the user if the command is used with the wrong arguments.
+     * If null is returned, the standard help (/<i>command</i> help) output is shown.
+     *
+     * @return the message explaining the command's usage, or {@code null} for default behavior
+     */
+    default MessageKey getArgumentsMismatchMessage() {
+        return null;
+    }
+
+}

src/main/java/fr/xephi/authme/command/FoundCommandResult.java

@@ -0,0 +1,79 @@
+package fr.xephi.authme.command;
+
+import java.util.List;
+
+/**
+ * Result of a command mapping by {@link CommandHandler}. An object of this class represents a successful mapping
+ * as well as erroneous ones, as communicated with {@link FoundResultStatus}.
+ * <p>
+ * Fields other than {@link FoundResultStatus} are available depending, among other factors, on the status:
+ * <ul>
+ *   <li>{@link FoundResultStatus#SUCCESS} entails that mapping the input to a command was successful. Therefore,
+ *       the command description, labels and arguments are set. The difference is 0.0.</li>
+ *   <li>{@link FoundResultStatus#INCORRECT_ARGUMENTS}: The received parts could be mapped to a command but the argument
+ *       count doesn't match. Guarantees that the command description field is not null; difference is 0.0</li>
+ *   <li>{@link FoundResultStatus#UNKNOWN_LABEL}: The labels could not be mapped to a command. The command description
+ *       may be set to the most similar command, or it may be null. Difference is above 0.0.</li>
+ *   <li>{@link FoundResultStatus#NO_PERMISSION}: The command could be matched properly but the sender does not have
+ *       permission to execute it.</li>
+ *   <li>{@link FoundResultStatus#MISSING_BASE_COMMAND} should never occur. All other fields may be null and any further
+ *       processing of the object should be aborted.</li>
+ * </ul>
+ */
+public class FoundCommandResult {
+
+    /**
+     * The command description instance.
+     */
+    private final CommandDescription commandDescription;
+    /**
+     * The labels used to invoke the command. This may be different for the same {@link ExecutableCommand} instance
+     * if multiple labels have been defined, e.g. "/authme register" and "/authme reg".
+     */
+    private final List<String> labels;
+    /** The command arguments. */
+    private final List<String> arguments;
+    /** The difference between the matched command and the supplied labels. */
+    private final double difference;
+    /** The status of the result (see class description). */
+    private final FoundResultStatus resultStatus;
+
+    /**
+     * Constructor.
+     *
+     * @param commandDescription The command description.
+     * @param labels             The labels used to access the command.
+     * @param arguments          The command arguments.
+     * @param difference         The difference between the supplied labels and the matched command.
+     * @param resultStatus       The status of the result.
+     */
+    public FoundCommandResult(CommandDescription commandDescription, List<String> labels, List<String> arguments,
+                              double difference, FoundResultStatus resultStatus) {
+        this.commandDescription = commandDescription;
+        this.labels = labels;
+        this.arguments = arguments;
+        this.difference = difference;
+        this.resultStatus = resultStatus;
+    }
+
+    public CommandDescription getCommandDescription() {
+        return this.commandDescription;
+    }
+
+    public List<String> getArguments() {
+        return this.arguments;
+    }
+
+    public List<String> getLabels() {
+        return this.labels;
+    }
+
+    public double getDifference() {
+        return difference;
+    }
+
+    public FoundResultStatus getResultStatus() {
+        return resultStatus;
+    }
+
+}

src/main/java/fr/xephi/authme/command/FoundResultStatus.java

@@ -0,0 +1,18 @@
+package fr.xephi.authme.command;
+
+/**
+ * Result status for mapping command parts. See {@link FoundCommandResult} for a detailed description of the states.
+ */
+public enum FoundResultStatus {
+
+    SUCCESS,
+
+    INCORRECT_ARGUMENTS,
+
+    UNKNOWN_LABEL,
+
+    NO_PERMISSION,
+
+    MISSING_BASE_COMMAND
+
+}

src/main/java/fr/xephi/authme/command/PlayerCommand.java

@@ -0,0 +1,45 @@
+package fr.xephi.authme.command;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+/**
+ * Common base type for player-only commands, handling the verification that the command sender is indeed a player.
+ */
+public abstract class PlayerCommand implements ExecutableCommand {
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        if (sender instanceof Player) {
+            runCommand((Player) sender, arguments);
+        } else {
+            String alternative = getAlternativeCommand();
+            if (alternative != null) {
+                sender.sendMessage("此命令仅限玩家使用!请使用 " + alternative + " .");
+            } else {
+                sender.sendMessage("此命令只能被玩家执行.");
+            }
+        }
+    }
+
+    /**
+     * Runs the command with the given player and arguments.
+     *
+     * @param player     the player who initiated the command
+     * @param arguments  the arguments supplied with the command
+     */
+    protected abstract void runCommand(Player player, List<String> arguments);
+
+    /**
+     * Returns an alternative command (textual representation) that is not restricted to players only.
+     * Example: {@code "/authme register <playerName> <password>"}
+     *
+     * @return Alternative command not restricted to players, or null if not applicable
+     */
+    protected String getAlternativeCommand() {
+        return null;
+    }
+
+}

src/main/java/fr/xephi/authme/command/executable/HelpCommand.java

@@ -0,0 +1,64 @@
+package fr.xephi.authme.command.executable;
+
+import fr.xephi.authme.command.CommandMapper;
+import fr.xephi.authme.command.CommandUtils;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.command.FoundCommandResult;
+import fr.xephi.authme.command.FoundResultStatus;
+import fr.xephi.authme.command.help.HelpProvider;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+import static fr.xephi.authme.command.FoundResultStatus.MISSING_BASE_COMMAND;
+import static fr.xephi.authme.command.FoundResultStatus.UNKNOWN_LABEL;
+import static fr.xephi.authme.command.help.HelpProvider.ALL_OPTIONS;
+import static fr.xephi.authme.command.help.HelpProvider.SHOW_ALTERNATIVES;
+import static fr.xephi.authme.command.help.HelpProvider.SHOW_CHILDREN;
+import static fr.xephi.authme.command.help.HelpProvider.SHOW_COMMAND;
+import static fr.xephi.authme.command.help.HelpProvider.SHOW_DESCRIPTION;
+
+/**
+ * Displays help information to a user.
+ */
+public class HelpCommand implements ExecutableCommand {
+
+    @Inject
+    private CommandMapper commandMapper;
+
+    @Inject
+    private HelpProvider helpProvider;
+
+
+    // Convention: arguments is not the actual invoked arguments but the command that was invoked,
+    // e.g. "/authme help register" would typically be arguments = [register], but here we pass [authme, register]
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        FoundCommandResult result = commandMapper.mapPartsToCommand(sender, arguments);
+
+        FoundResultStatus resultStatus = result.getResultStatus();
+        if (MISSING_BASE_COMMAND.equals(resultStatus)) {
+            sender.sendMessage(ChatColor.DARK_RED + "Could not get base command");
+            return;
+        } else if (UNKNOWN_LABEL.equals(resultStatus)) {
+            if (result.getCommandDescription() == null) {
+                sender.sendMessage(ChatColor.DARK_RED + "Unknown command");
+                return;
+            } else {
+                sender.sendMessage(ChatColor.GOLD + "Assuming " + ChatColor.WHITE
+                    + CommandUtils.constructCommandPath(result.getCommandDescription()));
+            }
+        }
+
+        int mappedCommandLevel = result.getCommandDescription().getLabelCount();
+        if (mappedCommandLevel == 1) {
+            helpProvider.outputHelp(sender, result,
+                SHOW_COMMAND | SHOW_DESCRIPTION | SHOW_CHILDREN | SHOW_ALTERNATIVES);
+        } else {
+            helpProvider.outputHelp(sender, result, ALL_OPTIONS);
+        }
+    }
+
+}

src/main/java/fr/xephi/authme/command/executable/authme/AccountsCommand.java

@@ -0,0 +1,74 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Shows all accounts registered by the same IP address for the given player name or IP address.
+ */
+public class AccountsCommand implements ExecutableCommand {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private CommonService commonService;
+
+    @Override
+    public void executeCommand(final CommandSender sender, List<String> arguments) {
+        // TODO #1366: last IP vs. registration IP?
+        final String playerName = arguments.isEmpty() ? sender.getName() : arguments.get(0);
+
+        // Assumption: a player name cannot contain '.'
+        if (playerName.contains(".")) {
+            bukkitService.runTaskAsynchronously(() -> {
+                List<String> accountList = dataSource.getAllAuthsByIp(playerName);
+                if (accountList.isEmpty()) {
+                    sender.sendMessage("[AuthMe] This IP does not exist in the database.");
+                } else if (accountList.size() == 1) {
+                    sender.sendMessage("[AuthMe] " + playerName + " is a single account player");
+                } else {
+                    outputAccountsList(sender, playerName, accountList);
+                }
+            });
+        } else {
+            bukkitService.runTaskAsynchronously(() -> {
+                PlayerAuth auth = dataSource.getAuth(playerName.toLowerCase(Locale.ROOT));
+                if (auth == null) {
+                    commonService.send(sender, MessageKey.UNKNOWN_USER);
+                    return;
+                } else if (auth.getLastIp() == null) {
+                    sender.sendMessage("No known last IP address for player");
+                    return;
+                }
+
+                List<String> accountList = dataSource.getAllAuthsByIp(auth.getLastIp());
+                if (accountList.isEmpty()) {
+                    commonService.send(sender, MessageKey.UNKNOWN_USER);
+                } else if (accountList.size() == 1) {
+                    sender.sendMessage("[AuthMe] " + playerName + " is a single account player");
+                } else {
+                    outputAccountsList(sender, playerName, accountList);
+                }
+            });
+        }
+    }
+
+    private static void outputAccountsList(CommandSender sender, String playerName, List<String> accountList) {
+        sender.sendMessage("[AuthMe] " + playerName + " has " + accountList.size() + " accounts.");
+        String message = "[AuthMe] " + String.join(", ", accountList) + ".";
+        sender.sendMessage(message);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/AuthMeCommand.java

@@ -0,0 +1,24 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.AuthMe;
+import fr.xephi.authme.command.ExecutableCommand;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import java.util.List;
+
+/**
+ * AuthMe base command; shows the version and some command pointers.
+ */
+public class AuthMeCommand implements ExecutableCommand {
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        sender.sendMessage(ChatColor.GREEN + "This server is running " + AuthMe.getPluginName() + " v"
+            + AuthMe.getPluginVersion() + " b" + AuthMe.getPluginBuildNumber()+ "! " + ChatColor.RED + "<3");
+        sender.sendMessage(ChatColor.YELLOW + "Use the command " + ChatColor.GOLD + "/authme help" + ChatColor.YELLOW
+            + " to view help.");
+        sender.sendMessage(ChatColor.YELLOW + "Use the command " + ChatColor.GOLD + "/authme about" + ChatColor.YELLOW
+            + " to view about.");
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/BackupCommand.java

@@ -0,0 +1,23 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.service.BackupService;
+import fr.xephi.authme.service.BackupService.BackupCause;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command to perform a backup.
+ */
+public class BackupCommand implements ExecutableCommand {
+
+    @Inject
+    private BackupService backupService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        backupService.doBackup(BackupCause.COMMAND, sender);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/ChangePasswordAdminCommand.java

@@ -0,0 +1,41 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.ValidationService;
+import fr.xephi.authme.service.ValidationService.ValidationResult;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Admin command for changing a player's password.
+ */
+public class ChangePasswordAdminCommand implements ExecutableCommand {
+
+    @Inject
+    private ValidationService validationService;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private Management management;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        // Get the player and password
+        final String playerName = arguments.get(0);
+        final String playerPass = arguments.get(1);
+
+        // Validate the password
+        ValidationResult validationResult = validationService.validatePassword(playerPass, playerName);
+        if (validationResult.hasError()) {
+            commonService.send(sender, validationResult.getMessageKey(), validationResult.getArgs());
+        } else {
+            management.performPasswordChangeAsAdmin(sender, playerName, playerPass);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/ConverterCommand.java

@@ -0,0 +1,95 @@
+package fr.xephi.authme.command.executable.authme;
+
+import ch.jalu.injector.factory.Factory;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableSortedMap;
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.converter.Converter;
+import fr.xephi.authme.datasource.converter.CrazyLoginConverter;
+import fr.xephi.authme.datasource.converter.LoginSecurityConverter;
+import fr.xephi.authme.datasource.converter.MySqlToSqlite;
+import fr.xephi.authme.datasource.converter.RakamakConverter;
+import fr.xephi.authme.datasource.converter.RoyalAuthConverter;
+import fr.xephi.authme.datasource.converter.SqliteToSql;
+import fr.xephi.authme.datasource.converter.VAuthConverter;
+import fr.xephi.authme.datasource.converter.XAuthConverter;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Converter command: launches conversion based on its parameters.
+ */
+public class ConverterCommand implements ExecutableCommand {
+
+    @VisibleForTesting
+    static final Map<String, Class<? extends Converter>> CONVERTERS = getConverters();
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(ConverterCommand.class);
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private Factory<Converter> converterFactory;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        Class<? extends Converter> converterClass = getConverterClassFromArgs(arguments);
+        if (converterClass == null) {
+            sender.sendMessage("Converters: " + String.join(", ", CONVERTERS.keySet()));
+            return;
+        }
+
+        // Get the proper converter instance
+        final Converter converter = converterFactory.newInstance(converterClass);
+
+        // Run the convert job
+        bukkitService.runTaskAsynchronously(() -> {
+            try {
+                converter.execute(sender);
+            } catch (Exception e) {
+                commonService.send(sender, MessageKey.ERROR);
+                logger.logException("Error during conversion:", e);
+            }
+        });
+
+        // Show a status message
+        sender.sendMessage("[AuthMe] Successfully started " + arguments.get(0));
+    }
+
+    private static Class<? extends Converter> getConverterClassFromArgs(List<String> arguments) {
+        return arguments.isEmpty()
+            ? null
+            : CONVERTERS.get(arguments.get(0).toLowerCase(Locale.ROOT));
+    }
+
+    /**
+     * Initializes a map with all available converters.
+     *
+     * @return map with all available converters
+     */
+    private static Map<String, Class<? extends Converter>> getConverters() {
+        return ImmutableSortedMap.<String, Class<? extends Converter>>naturalOrder()
+            .put("xauth", XAuthConverter.class)
+            .put("crazylogin", CrazyLoginConverter.class)
+            .put("rakamak", RakamakConverter.class)
+            .put("royalauth", RoyalAuthConverter.class)
+            .put("vauth", VAuthConverter.class)
+            .put("sqlitetosql", SqliteToSql.class)
+            .put("mysqltosqlite", MySqlToSqlite.class)
+            .put("loginsecurity", LoginSecurityConverter.class)
+            .build();
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/FirstSpawnCommand.java

@@ -0,0 +1,36 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.SpawnLoader;
+import fr.xephi.authme.settings.properties.SecuritySettings;
+import fr.xephi.authme.util.TeleportUtils;
+import org.bukkit.entity.Player;
+import fr.xephi.authme.AuthMe;
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Teleports the player to the first spawn.
+ */
+public class FirstSpawnCommand extends PlayerCommand {
+    @Inject
+    private Settings settings;
+    @Inject
+    private SpawnLoader spawnLoader;
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        if (spawnLoader.getFirstSpawn() == null) {
+            player.sendMessage("[AuthMe] First spawn has failed, please try to define the first spawn");
+        } else {
+            //String name= player.getName();
+            if(AuthMe.SATEnabled) {
+                TeleportUtils.teleport(player, spawnLoader.getFirstSpawn());
+            } else {
+                player.teleport(spawnLoader.getFirstSpawn());
+            }
+            //player.teleport(spawnLoader.getFirstSpawn());
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/ForceLoginCommand.java

@@ -0,0 +1,44 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.service.BukkitService;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+import static fr.xephi.authme.permission.PlayerPermission.CAN_LOGIN_BE_FORCED;
+
+/**
+ * Forces the login of a player, i.e. logs the player in without the need of a (correct) password.
+ */
+public class ForceLoginCommand implements ExecutableCommand {
+
+    @Inject
+    private PermissionsManager permissionsManager;
+
+    @Inject
+    private Management management;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        // Get the player query
+        String playerName = arguments.isEmpty() ? sender.getName() : arguments.get(0);
+
+        Player player = bukkitService.getPlayerExact(playerName);
+        if (player == null || !player.isOnline()) {
+            sender.sendMessage("Player needs to be online!");
+        } else if (!permissionsManager.hasPermission(player, CAN_LOGIN_BE_FORCED)) {
+            sender.sendMessage("You cannot force login the player " + playerName + "!");
+        } else {
+            management.forceLogin(player);
+            sender.sendMessage("Force login for " + playerName + " performed!");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/GetEmailCommand.java

@@ -0,0 +1,35 @@
+package fr.xephi.authme.command.executable.authme;
+
+import ch.jalu.datasourcecolumns.data.DataSourceValue;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Returns a player's email.
+ */
+public class GetEmailCommand implements ExecutableCommand {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private CommonService commonService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        String playerName = arguments.isEmpty() ? sender.getName() : arguments.get(0);
+
+        DataSourceValue<String> email = dataSource.getEmail(playerName);
+        if (email.rowExists()) {
+            sender.sendMessage("[AuthMe] " + playerName + "'s email: " + email.getValue());
+        } else {
+            commonService.send(sender, MessageKey.UNKNOWN_USER);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/GetIpCommand.java

@@ -0,0 +1,41 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.util.PlayerUtils;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+public class GetIpCommand implements ExecutableCommand {
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        String playerName = arguments.get(0);
+        Player player = bukkitService.getPlayerExact(playerName);
+        PlayerAuth auth = dataSource.getAuth(playerName);
+
+        if (player != null) {
+            sender.sendMessage("Current IP of " + player.getName() + " is " + PlayerUtils.getPlayerIp(player)
+                + ":" + player.getAddress().getPort());
+        }
+
+        if (auth == null) {
+            String displayName = player == null ? playerName : player.getName();
+            sender.sendMessage(displayName + " is not registered in the database");
+        } else {
+            sender.sendMessage("Database: last IP: " + auth.getLastIp() + ", registration IP: "
+                + auth.getRegistrationIp());
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/LastLoginCommand.java

@@ -0,0 +1,56 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Returns the last login date of the given user.
+ */
+public class LastLoginCommand implements ExecutableCommand {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private CommonService commonService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        // Get the player
+        String playerName = arguments.isEmpty() ? sender.getName() : arguments.get(0);
+
+        PlayerAuth auth = dataSource.getAuth(playerName);
+        if (auth == null) {
+            commonService.send(sender, MessageKey.UNKNOWN_USER);
+            return;
+        }
+
+        // Get the last login date
+        final Long lastLogin = auth.getLastLogin();
+        final String lastLoginDate = lastLogin == null ? "never" : new Date(lastLogin).toString();
+
+        // Show the player status
+        sender.sendMessage("[AuthMe] " + playerName + " last login: " + lastLoginDate);
+        if (lastLogin != null) {
+            sender.sendMessage("[AuthMe] The player " + playerName + " last logged in "
+                + createLastLoginIntervalMessage(lastLogin) + " ago");
+        }
+        sender.sendMessage("[AuthMe] Last player's IP: " + auth.getLastIp());
+    }
+
+    private static String createLastLoginIntervalMessage(long lastLogin) {
+        final long diff = System.currentTimeMillis() - lastLogin;
+        return (int) (diff / 86400000) + " days "
+            + (int) (diff / 3600000 % 24) + " hours "
+            + (int) (diff / 60000 % 60) + " mins "
+            + (int) (diff / 1000 % 60) + " secs";
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommand.java

@@ -0,0 +1,38 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.task.purge.PurgeService;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * Command for purging data of banned players. Depending on the settings
+ * it purges (deletes) data from third-party plugins as well.
+ */
+public class PurgeBannedPlayersCommand implements ExecutableCommand {
+
+    @Inject
+    private PurgeService purgeService;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        // Get the list of banned players
+        Set<OfflinePlayer> bannedPlayers = bukkitService.getBannedPlayers();
+        Set<String> namedBanned = new HashSet<>(bannedPlayers.size());
+        for (OfflinePlayer offlinePlayer : bannedPlayers) {
+            namedBanned.add(offlinePlayer.getName().toLowerCase(Locale.ROOT));
+        }
+
+        purgeService.purgePlayers(sender, namedBanned, bannedPlayers.toArray(new OfflinePlayer[bannedPlayers.size()]));
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/PurgeCommand.java

@@ -0,0 +1,51 @@
+package fr.xephi.authme.command.executable.authme;
+
+import com.google.common.primitives.Ints;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.task.purge.PurgeService;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.Calendar;
+import java.util.List;
+
+/**
+ * Command for purging the data of players which have not been online for a given number
+ * of days. Depending on the settings, this removes player data in third-party plugins as well.
+ */
+public class PurgeCommand implements ExecutableCommand {
+
+    private static final int MINIMUM_LAST_SEEN_DAYS = 30;
+
+    @Inject
+    private PurgeService purgeService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        // Get the days parameter
+        String daysStr = arguments.get(0);
+
+        // Convert the days string to an integer value, and make sure it's valid
+        Integer days = Ints.tryParse(daysStr);
+        if (days == null) {
+            sender.sendMessage(ChatColor.RED + "The value you've entered is invalid!");
+            return;
+        }
+
+        // Validate the value
+        if (days < MINIMUM_LAST_SEEN_DAYS) {
+            sender.sendMessage(ChatColor.RED + "You can only purge data older than "
+                + MINIMUM_LAST_SEEN_DAYS + " days");
+            return;
+        }
+
+        // Create a calender instance to determine the date
+        Calendar calendar = Calendar.getInstance();
+        calendar.add(Calendar.DATE, -days);
+        long until = calendar.getTimeInMillis();
+
+        // Run the purge
+        purgeService.runPurge(sender, until);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/PurgeLastPositionCommand.java

@@ -0,0 +1,56 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Removes the stored last position of a user or of all.
+ */
+public class PurgeLastPositionCommand implements ExecutableCommand {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private CommonService commonService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        String playerName = arguments.isEmpty() ? sender.getName() : arguments.get(0);
+
+        if ("*".equals(playerName)) {
+            for (PlayerAuth auth : dataSource.getAllAuths()) {
+                resetLastPosition(auth);
+                dataSource.updateQuitLoc(auth);
+                // TODO: send an update when a messaging service will be implemented (QUITLOC)
+            }
+            sender.sendMessage("All players last position locations are now reset");
+        } else {
+            // Get the user auth and make sure the user exists
+            PlayerAuth auth = dataSource.getAuth(playerName);
+            if (auth == null) {
+                commonService.send(sender, MessageKey.UNKNOWN_USER);
+                return;
+            }
+
+            resetLastPosition(auth);
+            dataSource.updateQuitLoc(auth);
+            // TODO: send an update when a messaging service will be implemented (QUITLOC)
+            sender.sendMessage(playerName + "'s last position location is now reset");
+        }
+    }
+
+    private static void resetLastPosition(PlayerAuth auth) {
+        auth.setQuitLocX(0d);
+        auth.setQuitLocY(0d);
+        auth.setQuitLocZ(0d);
+        auth.setWorld("world");
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/PurgePlayerCommand.java

@@ -0,0 +1,47 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.task.purge.PurgeExecutor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Locale;
+
+import static java.util.Collections.singletonList;
+
+/**
+ * Command to purge a player.
+ */
+public class PurgePlayerCommand implements ExecutableCommand {
+
+    @Inject
+    private PurgeExecutor purgeExecutor;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        String option = arguments.size() > 1 ? arguments.get(1) : null;
+        bukkitService.runTaskAsynchronously(
+            () -> executeCommand(sender, arguments.get(0), option));
+    }
+
+    private void executeCommand(CommandSender sender, String name, String option) {
+        if ("force".equals(option) || !dataSource.isAuthAvailable(name)) {
+            OfflinePlayer offlinePlayer = bukkitService.getOfflinePlayer(name);
+            purgeExecutor.executePurge(singletonList(offlinePlayer), singletonList(name.toLowerCase(Locale.ROOT)));
+            sender.sendMessage("Purged data for player " + name);
+        } else {
+            sender.sendMessage("This player is still registered! Are you sure you want to proceed? "
+                + "Use '/authme purgeplayer " + name + " force' to run the command anyway");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/RecentPlayersCommand.java

@@ -0,0 +1,55 @@
+package fr.xephi.authme.command.executable.authme;
+
+import com.google.common.annotations.VisibleForTesting;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import static java.time.Instant.ofEpochMilli;
+
+/**
+ * Command showing the most recent logged in players.
+ */
+public class RecentPlayersCommand implements ExecutableCommand {
+
+    /** DateTime formatter, producing Strings such as "10:42 AM, 11 Jul". */
+    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("hh:mm a, dd MMM");
+
+    @Inject
+    private DataSource dataSource;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        List<PlayerAuth> recentPlayers = dataSource.getRecentlyLoggedInPlayers();
+
+        sender.sendMessage(ChatColor.BLUE + "[AuthMe] Recently logged in players");
+        for (PlayerAuth auth : recentPlayers) {
+            sender.sendMessage(formatPlayerMessage(auth));
+        }
+    }
+
+    @VisibleForTesting
+    ZoneId getZoneId() {
+        return ZoneId.systemDefault();
+    }
+
+    private String formatPlayerMessage(PlayerAuth auth) {
+        String lastLoginText;
+        if (auth.getLastLogin() == null) {
+            lastLoginText = "never";
+        } else {
+            LocalDateTime lastLogin = LocalDateTime.ofInstant(ofEpochMilli(auth.getLastLogin()), getZoneId());
+            lastLoginText = DATE_FORMAT.format(lastLogin);
+        }
+
+        return "- " + auth.getRealName() + " (" + lastLoginText + " with IP " + auth.getLastIp() + ")";
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/RegisterAdminCommand.java

@@ -0,0 +1,85 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.security.PasswordSecurity;
+import fr.xephi.authme.security.crypts.HashedPassword;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.ValidationService;
+import fr.xephi.authme.service.ValidationService.ValidationResult;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Admin command to register a user.
+ */
+public class RegisterAdminCommand implements ExecutableCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(RegisterAdminCommand.class);
+
+    @Inject
+    private PasswordSecurity passwordSecurity;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private ValidationService validationService;
+
+    @Override
+    public void executeCommand(final CommandSender sender, List<String> arguments) {
+        // Get the player name and password
+        final String playerName = arguments.get(0);
+        final String playerPass = arguments.get(1);
+        final String playerNameLowerCase = playerName.toLowerCase(Locale.ROOT);
+
+        // Command logic
+        ValidationResult passwordValidation = validationService.validatePassword(playerPass, playerName);
+        if (passwordValidation.hasError()) {
+            commonService.send(sender, passwordValidation.getMessageKey(), passwordValidation.getArgs());
+            return;
+        }
+
+        bukkitService.runTaskOptionallyAsync(() -> {
+            if (dataSource.isAuthAvailable(playerNameLowerCase)) {
+                commonService.send(sender, MessageKey.NAME_ALREADY_REGISTERED);
+                return;
+            }
+            HashedPassword hashedPassword = passwordSecurity.computeHash(playerPass, playerNameLowerCase);
+            PlayerAuth auth = PlayerAuth.builder()
+                .name(playerNameLowerCase)
+                .realName(playerName)
+                .password(hashedPassword)
+                .registrationDate(System.currentTimeMillis())
+                .build();
+
+            if (!dataSource.saveAuth(auth)) {
+                commonService.send(sender, MessageKey.ERROR);
+                return;
+            }
+
+            commonService.send(sender, MessageKey.REGISTER_SUCCESS);
+            logger.info(sender.getName() + " registered " + playerName);
+            final Player player = bukkitService.getPlayerExact(playerName);
+            if (player != null) {
+                bukkitService.scheduleSyncTaskFromOptionallyAsyncTask(() ->
+                    player.kickPlayer(commonService.retrieveSingleMessage(player, MessageKey.KICK_FOR_ADMIN_REGISTER)));
+            }
+        });
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/ReloadCommand.java

@@ -0,0 +1,77 @@
+package fr.xephi.authme.command.executable.authme;
+
+import ch.jalu.injector.factory.SingletonStore;
+import fr.xephi.authme.AuthMe;
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.initialization.Reloadable;
+import fr.xephi.authme.initialization.SettingsDependent;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.SettingsWarner;
+import fr.xephi.authme.settings.properties.DatabaseSettings;
+import fr.xephi.authme.util.Utils;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * The reload command.
+ */
+public class ReloadCommand implements ExecutableCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(ReloadCommand.class);
+
+    @Inject
+    private AuthMe plugin;
+
+    @Inject
+    private Settings settings;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private SettingsWarner settingsWarner;
+
+    @Inject
+    private SingletonStore<Reloadable> reloadableStore;
+
+    @Inject
+    private SingletonStore<SettingsDependent> settingsDependentStore;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        try {
+            settings.reload();
+            ConsoleLoggerFactory.reloadSettings(settings);
+            settingsWarner.logWarningsForMisconfigurations();
+
+            // We do not change database type for consistency issues, but we'll output a note in the logs
+            if (!settings.getProperty(DatabaseSettings.BACKEND).equals(dataSource.getType())) {
+                Utils.logAndSendMessage(sender, "Note: cannot change database type during /authme reload");
+            }
+            performReloadOnServices();
+            commonService.send(sender, MessageKey.CONFIG_RELOAD_SUCCESS);
+        } catch (Exception e) {
+            sender.sendMessage("Error occurred during reload of AuthMe: aborting");
+            logger.logException("Aborting! Encountered exception during reload of AuthMe:", e);
+            plugin.stopOrUnload();
+        }
+    }
+
+    private void performReloadOnServices() {
+        reloadableStore.retrieveAllOfType()
+            .forEach(r -> r.reload());
+
+        settingsDependentStore.retrieveAllOfType()
+            .forEach(s -> s.reload(settings));
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/SetEmailCommand.java

@@ -0,0 +1,78 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.ValidationService;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Admin command for setting an email to an account.
+ */
+public class SetEmailCommand implements ExecutableCommand {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private ValidationService validationService;
+
+    @Override
+    public void executeCommand(final CommandSender sender, List<String> arguments) {
+        // Get the player name and email address
+        final String playerName = arguments.get(0);
+        final String playerEmail = arguments.get(1);
+
+        // Validate the email address
+        if (!validationService.validateEmail(playerEmail)) {
+            commonService.send(sender, MessageKey.INVALID_EMAIL);
+            return;
+        }
+
+        bukkitService.runTaskOptionallyAsync(new Runnable() {
+            @Override
+            public void run() {
+                // Validate the user
+                PlayerAuth auth = dataSource.getAuth(playerName);
+                if (auth == null) {
+                    commonService.send(sender, MessageKey.UNKNOWN_USER);
+                    return;
+                } else if (!validationService.isEmailFreeForRegistration(playerEmail, sender)) {
+                    commonService.send(sender, MessageKey.EMAIL_ALREADY_USED_ERROR);
+                    return;
+                }
+
+                // Set the email address
+                auth.setEmail(playerEmail);
+                if (!dataSource.updateEmail(auth)) {
+                    commonService.send(sender, MessageKey.ERROR);
+                    return;
+                }
+
+                // Update the player cache
+                if (playerCache.getAuth(playerName) != null) {
+                    playerCache.updatePlayer(auth);
+                }
+
+                // Show a status message
+                commonService.send(sender, MessageKey.EMAIL_CHANGED_SUCCESS);
+            }
+        });
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/SetFirstSpawnCommand.java

@@ -0,0 +1,23 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.settings.SpawnLoader;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+public class SetFirstSpawnCommand extends PlayerCommand {
+
+    @Inject
+    private SpawnLoader spawnLoader;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        if (spawnLoader.setFirstSpawn(player.getLocation())) {
+            player.sendMessage("[AuthMe] Correctly defined new first spawn point");
+        } else {
+            player.sendMessage("[AuthMe] SetFirstSpawn has failed, please retry");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/SetSpawnCommand.java

@@ -0,0 +1,23 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.settings.SpawnLoader;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+public class SetSpawnCommand extends PlayerCommand {
+
+    @Inject
+    private SpawnLoader spawnLoader;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        if (spawnLoader.setSpawn(player.getLocation())) {
+            player.sendMessage("[AuthMe] Correctly defined new spawn point");
+        } else {
+            player.sendMessage("[AuthMe] SetSpawn has failed, please retry");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/SpawnCommand.java

@@ -0,0 +1,23 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.settings.SpawnLoader;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+public class SpawnCommand extends PlayerCommand {
+
+    @Inject
+    private SpawnLoader spawnLoader;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        if (spawnLoader.getSpawn() == null) {
+            player.sendMessage("[AuthMe] Spawn has failed, please try to define the spawn");
+        } else {
+            player.teleport(spawnLoader.getSpawn());
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/SwitchAntiBotCommand.java

@@ -0,0 +1,52 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.CommandMapper;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.command.FoundCommandResult;
+import fr.xephi.authme.command.help.HelpProvider;
+import fr.xephi.authme.service.AntiBotService;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Display or change the status of the antibot mod.
+ */
+public class SwitchAntiBotCommand implements ExecutableCommand {
+
+    @Inject
+    private AntiBotService antiBotService;
+
+    @Inject
+    private CommandMapper commandMapper;
+
+    @Inject
+    private HelpProvider helpProvider;
+
+    @Override
+    public void executeCommand(final CommandSender sender, List<String> arguments) {
+        if (arguments.isEmpty()) {
+            sender.sendMessage("[AuthMe] AntiBot status: " + antiBotService.getAntiBotStatus().name());
+            return;
+        }
+
+        String newState = arguments.get(0);
+
+        // Enable or disable the mod
+        if ("ON".equalsIgnoreCase(newState)) {
+            antiBotService.overrideAntiBotStatus(true);
+            sender.sendMessage("[AuthMe] AntiBot Manual Override: enabled!");
+        } else if ("OFF".equalsIgnoreCase(newState)) {
+            antiBotService.overrideAntiBotStatus(false);
+            sender.sendMessage("[AuthMe] AntiBot Manual Override: disabled!");
+        } else {
+            sender.sendMessage(ChatColor.DARK_RED + "Invalid AntiBot mode!");
+            FoundCommandResult result = commandMapper.mapPartsToCommand(sender, Arrays.asList("authme", "antibot"));
+            helpProvider.outputHelp(sender, result, HelpProvider.SHOW_ARGUMENTS);
+            sender.sendMessage(ChatColor.GOLD + "Detailed help: " + ChatColor.WHITE + "/authme help antibot");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/TotpDisableAdminCommand.java

@@ -0,0 +1,61 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.service.BukkitService;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command to disable two-factor authentication for a user.
+ */
+public class TotpDisableAdminCommand implements ExecutableCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(TotpDisableAdminCommand.class);
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private Messages messages;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        String player = arguments.get(0);
+
+        PlayerAuth auth = dataSource.getAuth(player);
+        if (auth == null) {
+            messages.send(sender, MessageKey.UNKNOWN_USER);
+        } else if (auth.getTotpKey() == null) {
+            sender.sendMessage(ChatColor.RED + "Player '" + player + "' does not have two-factor auth enabled");
+        } else {
+            removeTotpKey(sender, player);
+        }
+    }
+
+    private void removeTotpKey(CommandSender sender, String player) {
+        if (dataSource.removeTotpKey(player)) {
+            sender.sendMessage("Disabled two-factor authentication successfully for '" + player + "'");
+            logger.info(sender.getName() + " disable two-factor authentication for '" + player + "'");
+
+            Player onlinePlayer = bukkitService.getPlayerExact(player);
+            if (onlinePlayer != null) {
+                messages.send(onlinePlayer, MessageKey.TWO_FACTOR_REMOVED_SUCCESS);
+            }
+        } else {
+            messages.send(sender, MessageKey.ERROR);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/TotpViewStatusCommand.java

@@ -0,0 +1,38 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command to see whether a user has enabled two-factor authentication.
+ */
+public class TotpViewStatusCommand implements ExecutableCommand {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private Messages messages;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        String player = arguments.get(0);
+
+        PlayerAuth auth = dataSource.getAuth(player);
+        if (auth == null) {
+            messages.send(sender, MessageKey.UNKNOWN_USER);
+        } else if (auth.getTotpKey() == null) {
+            sender.sendMessage(ChatColor.RED + "Player '" + player + "' does NOT have two-factor auth enabled");
+        } else {
+            sender.sendMessage(ChatColor.DARK_GREEN + "Player '" + player + "' has enabled two-factor authentication");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/UnregisterAdminCommand.java

@@ -0,0 +1,49 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Admin command to unregister a player.
+ */
+public class UnregisterAdminCommand implements ExecutableCommand {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private Management management;
+
+    UnregisterAdminCommand() {
+    }
+
+    @Override
+    public void executeCommand(final CommandSender sender, List<String> arguments) {
+        String playerName = arguments.get(0);
+
+        // Make sure the user exists
+        if (!dataSource.isAuthAvailable(playerName)) {
+            commonService.send(sender, MessageKey.UNKNOWN_USER);
+            return;
+        }
+
+        // Get the player from the server and perform unregister
+        Player target = bukkitService.getPlayerExact(playerName);
+        management.performUnregisterByAdmin(sender, playerName, target);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/UpdateHelpMessagesCommand.java

@@ -0,0 +1,39 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.command.help.HelpMessagesService;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.service.HelpTranslationGenerator;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Messages command, updates the user's help messages file with any missing files
+ * from the provided file in the JAR.
+ */
+public class UpdateHelpMessagesCommand implements ExecutableCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(UpdateHelpMessagesCommand.class);
+
+    @Inject
+    private HelpTranslationGenerator helpTranslationGenerator;
+    @Inject
+    private HelpMessagesService helpMessagesService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        try {
+            File updatedFile = helpTranslationGenerator.updateHelpFile();
+            sender.sendMessage("Successfully updated the help file '" + updatedFile.getName() + "'");
+            helpMessagesService.reloadMessagesFile();
+        } catch (IOException e) {
+            sender.sendMessage("Could not update help file: " + e.getMessage());
+            logger.logException("Could not update help file:", e);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/VersionCommand.java

@@ -0,0 +1,94 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.AuthMe;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.service.BukkitService;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.text.SimpleDateFormat;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
+public class VersionCommand implements ExecutableCommand {
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        // Show some version info
+        sender.sendMessage(ChatColor.GOLD + "==========[ " + AuthMe.getPluginName() + " ABOUT ]==========");
+        sender.sendMessage(ChatColor.GOLD + "Version: " + ChatColor.WHITE + AuthMe.getPluginName()
+            + " v" + AuthMe.getPluginVersion() + ChatColor.GRAY + " (build: " + AuthMe.getPluginBuildNumber() + ")");
+        sender.sendMessage(ChatColor.GOLD + "Authors:");
+        Collection<Player> onlinePlayers = bukkitService.getOnlinePlayers();
+        printDeveloper(sender, "Gabriele C.", "sgdc3", "Project manager, Contributor", onlinePlayers);
+        printDeveloper(sender, "Lucas J.", "ljacqu", "Main Developer", onlinePlayers);
+        printDeveloper(sender, "games647", "games647", "Developer", onlinePlayers);
+        printDeveloper(sender, "Hex3l", "Hex3l", "Developer", onlinePlayers);
+        printDeveloper(sender, "krusic22", "krusic22", "Support", onlinePlayers);
+        sender.sendMessage(ChatColor.GOLD + "Retired authors:");
+        printDeveloper(sender, "Alexandre Vanhecke", "xephi59", "Original Author", onlinePlayers);
+        printDeveloper(sender, "Gnat008", "gnat008", "Developer, Retired", onlinePlayers);
+        printDeveloper(sender, "DNx5", "DNx5", "Developer, Retired", onlinePlayers);
+        printDeveloper(sender, "Tim Visee", "timvisee", "Developer, Retired", onlinePlayers);
+        sender.sendMessage(ChatColor.GOLD + "Website: " + ChatColor.WHITE
+            + "https://github.com/AuthMe/AuthMeReloaded");
+        sender.sendMessage(ChatColor.GOLD + "License: " + ChatColor.WHITE + "GNU GPL v3.0"
+            + ChatColor.GRAY + ChatColor.ITALIC + " (See LICENSE file)");
+        sender.sendMessage(ChatColor.GOLD + "Copyright: " + ChatColor.WHITE
+            + "Copyright (c) AuthMe-Team " + new SimpleDateFormat("yyyy").format(new Date())
+            + ". Released under GPL v3 License.");
+    }
+
+    /**
+     * Print a developer with proper styling.
+     *
+     * @param sender        The command sender
+     * @param name          The display name of the developer
+     * @param minecraftName The Minecraft username of the developer, if available
+     * @param function      The function of the developer
+     * @param onlinePlayers The list of online players
+     */
+    private static void printDeveloper(CommandSender sender, String name, String minecraftName, String function,
+                                       Collection<Player> onlinePlayers) {
+        // Print the name
+        StringBuilder msg = new StringBuilder();
+        msg.append(" ")
+            .append(ChatColor.WHITE)
+            .append(name);
+
+        // Append the Minecraft name
+        msg.append(ChatColor.GRAY).append(" // ").append(ChatColor.WHITE).append(minecraftName);
+        msg.append(ChatColor.GRAY).append(ChatColor.ITALIC).append(" (").append(function).append(")");
+
+        // Show the online status
+        if (isPlayerOnline(minecraftName, onlinePlayers)) {
+            msg.append(ChatColor.GREEN).append(ChatColor.ITALIC).append(" (In-Game)");
+        }
+
+        // Print the message
+        sender.sendMessage(msg.toString());
+    }
+
+    /**
+     * Check whether a player is online.
+     *
+     * @param minecraftName The Minecraft player name
+     * @param onlinePlayers List of online players
+     *
+     * @return True if the player is online, false otherwise
+     */
+    private static boolean isPlayerOnline(String minecraftName, Collection<Player> onlinePlayers) {
+        for (Player player : onlinePlayers) {
+            if (player.getName().equalsIgnoreCase(minecraftName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/CountryLookup.java

@@ -0,0 +1,88 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.service.GeoIpService;
+import fr.xephi.authme.service.ValidationService;
+import fr.xephi.authme.settings.properties.ProtectionSettings;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * Shows the GeoIP information as returned by the geoIpService.
+ */
+class CountryLookup implements DebugSection {
+
+    private static final Pattern IS_IP_ADDR = Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}");
+
+    @Inject
+    private GeoIpService geoIpService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private ValidationService validationService;
+
+    @Override
+    public String getName() {
+        return "cty";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Check country protection / country data";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        sender.sendMessage(ChatColor.BLUE + "AuthMe country lookup");
+        if (arguments.isEmpty()) {
+            sender.sendMessage("Check player: /authme debug cty Bobby");
+            sender.sendMessage("Check IP address: /authme debug cty 127.123.45.67");
+            return;
+        }
+
+        String argument = arguments.get(0);
+        if (IS_IP_ADDR.matcher(argument).matches()) {
+            outputInfoForIpAddr(sender, argument);
+        } else {
+            outputInfoForPlayer(sender, argument);
+        }
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.COUNTRY_LOOKUP;
+    }
+
+    private void outputInfoForIpAddr(CommandSender sender, String ipAddr) {
+        sender.sendMessage("IP '" + ipAddr + "' maps to country '" + geoIpService.getCountryCode(ipAddr)
+            + "' (" + geoIpService.getCountryName(ipAddr) + ")");
+        if (validationService.isCountryAdmitted(ipAddr)) {
+            sender.sendMessage(ChatColor.DARK_GREEN + "This IP address' country is not blocked");
+        } else {
+            sender.sendMessage(ChatColor.DARK_RED + "This IP address' country is blocked from the server");
+        }
+        sender.sendMessage("Note: if " + ProtectionSettings.ENABLE_PROTECTION + " is false no country is blocked");
+    }
+
+    // TODO #1366: Extend with registration IP?
+    private void outputInfoForPlayer(CommandSender sender, String name) {
+        PlayerAuth auth = dataSource.getAuth(name);
+        if (auth == null) {
+            sender.sendMessage("No player with name '" + name + "'");
+        } else if (auth.getLastIp() == null) {
+            sender.sendMessage("No last IP address known for '" + name + "'");
+        } else {
+            sender.sendMessage("Player '" + name + "' has IP address " + auth.getLastIp());
+            outputInfoForIpAddr(sender, auth.getLastIp());
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/DataStatistics.java

@@ -0,0 +1,81 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import ch.jalu.injector.factory.SingletonStore;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.datasource.CacheDataSource;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.initialization.HasCleanup;
+import fr.xephi.authme.initialization.Reloadable;
+import fr.xephi.authme.initialization.SettingsDependent;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Map;
+
+import static fr.xephi.authme.command.executable.authme.debug.DebugSectionUtils.applyToLimboPlayersMap;
+
+/**
+ * Fetches various statistics, particularly regarding in-memory data that is stored.
+ */
+class DataStatistics implements DebugSection {
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private LimboService limboService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private SingletonStore<Object> singletonStore;
+
+    @Override
+    public String getName() {
+        return "stats";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Outputs general data statistics";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        sender.sendMessage(ChatColor.BLUE + "AuthMe statistics");
+        sender.sendMessage("LimboPlayers in memory: " + applyToLimboPlayersMap(limboService, Map::size));
+        sender.sendMessage("PlayerCache size: " + playerCache.getLogged() + " (= logged in players)");
+
+        outputDatabaseStats(sender);
+        outputInjectorStats(sender);
+        sender.sendMessage("Total logger instances: " + ConsoleLoggerFactory.getTotalLoggers());
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.DATA_STATISTICS;
+    }
+
+    private void outputDatabaseStats(CommandSender sender) {
+        sender.sendMessage("Total players in DB: " + dataSource.getAccountsRegistered());
+        if (dataSource instanceof CacheDataSource) {
+            CacheDataSource cacheDataSource = (CacheDataSource) this.dataSource;
+            sender.sendMessage("Cached PlayerAuth objects: " + cacheDataSource.getCachedAuths().size());
+        }
+    }
+
+    private void outputInjectorStats(CommandSender sender) {
+        sender.sendMessage("Singleton Java classes: " + singletonStore.retrieveAllOfType().size());
+        sender.sendMessage(String.format("(Reloadable: %d / SettingsDependent: %d / HasCleanup: %d)",
+            singletonStore.retrieveAllOfType(Reloadable.class).size(),
+            singletonStore.retrieveAllOfType(SettingsDependent.class).size(),
+            singletonStore.retrieveAllOfType(HasCleanup.class).size()));
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/DebugCommand.java

@@ -0,0 +1,85 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import ch.jalu.injector.factory.Factory;
+import com.google.common.collect.ImmutableSet;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.permission.PermissionsManager;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/**
+ * Debug command main.
+ */
+public class DebugCommand implements ExecutableCommand {
+
+    private static final Set<Class<? extends DebugSection>> SECTION_CLASSES = ImmutableSet.of(
+        PermissionGroups.class, DataStatistics.class, CountryLookup.class, PlayerAuthViewer.class, InputValidator.class,
+        LimboPlayerViewer.class, CountryLookup.class, HasPermissionChecker.class, TestEmailSender.class,
+        SpawnLocationViewer.class, MySqlDefaultChanger.class);
+
+    @Inject
+    private Factory<DebugSection> debugSectionFactory;
+
+    @Inject
+    private PermissionsManager permissionsManager;
+
+    private Map<String, DebugSection> sections;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        DebugSection debugSection = findDebugSection(arguments);
+        if (debugSection == null) {
+            sendAvailableSections(sender);
+        } else {
+            executeSection(debugSection, sender, arguments);
+        }
+    }
+
+    private DebugSection findDebugSection(List<String> arguments) {
+        if (arguments.isEmpty()) {
+            return null;
+        }
+        return getSections().get(arguments.get(0).toLowerCase(Locale.ROOT));
+    }
+
+    private void sendAvailableSections(CommandSender sender) {
+        sender.sendMessage(ChatColor.BLUE + "AuthMe debug utils");
+        sender.sendMessage("Sections available to you:");
+        long availableSections = getSections().values().stream()
+            .filter(section -> permissionsManager.hasPermission(sender, section.getRequiredPermission()))
+            .peek(e -> sender.sendMessage("- " + e.getName() + ": " + e.getDescription()))
+            .count();
+
+        if (availableSections == 0) {
+            sender.sendMessage(ChatColor.RED + "You don't have permission to view any debug section");
+        }
+    }
+
+    private void executeSection(DebugSection section, CommandSender sender, List<String> arguments) {
+        if (permissionsManager.hasPermission(sender, section.getRequiredPermission())) {
+            section.execute(sender, arguments.subList(1, arguments.size()));
+        } else {
+            sender.sendMessage(ChatColor.RED + "You don't have permission for this section. See /authme debug");
+        }
+    }
+
+    // Lazy getter
+    private Map<String, DebugSection> getSections() {
+        if (sections == null) {
+            Map<String, DebugSection> sections = new TreeMap<>();
+            for (Class<? extends DebugSection> sectionClass : SECTION_CLASSES) {
+                DebugSection section = debugSectionFactory.newInstance(sectionClass);
+                sections.put(section.getName(), section);
+            }
+            this.sections = sections;
+        }
+        return sections;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/DebugSection.java

@@ -0,0 +1,36 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.permission.PermissionNode;
+import org.bukkit.command.CommandSender;
+
+import java.util.List;
+
+/**
+ * A debug section: "child" command of the debug command.
+ */
+interface DebugSection {
+
+    /**
+     * @return the name to get to this child command
+     */
+    String getName();
+
+    /**
+     * @return short description of the child command
+     */
+    String getDescription();
+
+    /**
+     * Executes the debug child command.
+     *
+     * @param sender the sender executing the command
+     * @param arguments the arguments, without the label of the child command
+     */
+    void execute(CommandSender sender, List<String> arguments);
+
+    /**
+     * @return permission required to run this section
+     */
+    PermissionNode getRequiredPermission();
+
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionUtils.java

@@ -0,0 +1,130 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.datasource.CacheDataSource;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import org.bukkit.Location;
+
+import java.lang.reflect.Field;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * Utilities used within the DebugSection implementations.
+ */
+final class DebugSectionUtils {
+
+    private static ConsoleLogger logger = ConsoleLoggerFactory.get(DebugSectionUtils.class);
+    private static Field limboEntriesField;
+
+    private DebugSectionUtils() {
+    }
+
+    /**
+     * Formats the given location in a human readable way. Null-safe.
+     *
+     * @param location the location to format
+     * @return the formatted location
+     */
+    static String formatLocation(Location location) {
+        if (location == null) {
+            return "null";
+        }
+
+        String worldName = location.getWorld() == null ? "null" : location.getWorld().getName();
+        return formatLocation(location.getX(), location.getY(), location.getZ(), worldName);
+    }
+
+    /**
+     * Formats the given location in a human readable way.
+     *
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param z the z coordinate
+     * @param world the world name
+     * @return the formatted location
+     */
+    static String formatLocation(double x, double y, double z, String world) {
+        return "(" + round(x) + ", " + round(y) + ", " + round(z) + ") in '" + world + "'";
+    }
+
+    /**
+     * Rounds the given number to two decimals.
+     *
+     * @param number the number to round
+     * @return the rounded number
+     */
+    private static String round(double number) {
+        DecimalFormat df = new DecimalFormat("#.##");
+        df.setDecimalFormatSymbols(DecimalFormatSymbols.getInstance(Locale.US));
+        df.setRoundingMode(RoundingMode.HALF_UP);
+        return df.format(number);
+    }
+
+    private static Field getLimboPlayerEntriesField() {
+        if (limboEntriesField == null) {
+            try {
+                Field field = LimboService.class.getDeclaredField("entries");
+                field.setAccessible(true);
+                limboEntriesField = field;
+            } catch (Exception e) {
+                logger.logException("Could not retrieve LimboService entries field:", e);
+            }
+        }
+        return limboEntriesField;
+    }
+
+    /**
+     * Applies the given function to the map in LimboService containing the LimboPlayers.
+     * As we don't want to expose this information in non-debug settings, this is done with reflection.
+     * Exceptions are generously caught and {@code null} is returned on failure.
+     *
+     * @param limboService the limbo service instance to get the map from
+     * @param function the function to apply to the map
+     * @param <U> the result type of the function
+     *
+     * @return the value of the function applied to the map, or null upon error
+     */
+    static <U> U applyToLimboPlayersMap(LimboService limboService, Function<Map, U> function) {
+        Field limboPlayerEntriesField = getLimboPlayerEntriesField();
+        if (limboPlayerEntriesField != null) {
+            try {
+                return function.apply((Map) limboEntriesField.get(limboService));
+            } catch (Exception e) {
+                logger.logException("Could not retrieve LimboService values:", e);
+            }
+        }
+        return null;
+    }
+
+    static <T> T castToTypeOrNull(Object object, Class<T> clazz) {
+        return clazz.isInstance(object) ? clazz.cast(object) : null;
+    }
+
+    /**
+     * Unwraps the "cache data source" and returns the underlying source. Returns the
+     * same as the input argument otherwise.
+     *
+     * @param dataSource the data source to unwrap if applicable
+     * @return the non-cache data source
+     */
+    static DataSource unwrapSourceFromCacheDataSource(DataSource dataSource) {
+        if (dataSource instanceof CacheDataSource) {
+            try {
+                Field source = CacheDataSource.class.getDeclaredField("source");
+                source.setAccessible(true);
+                return (DataSource) source.get(dataSource);
+            } catch (NoSuchFieldException | IllegalAccessException e) {
+                logger.logException("Could not get source of CacheDataSource:", e);
+                return null;
+            }
+        }
+        return dataSource;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/HasPermissionChecker.java

@@ -0,0 +1,138 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import com.google.common.collect.ImmutableList;
+import fr.xephi.authme.permission.AdminPermission;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.DefaultPermission;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.permission.PlayerPermission;
+import fr.xephi.authme.permission.PlayerStatePermission;
+import fr.xephi.authme.service.BukkitService;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.BiFunction;
+
+/**
+ * Checks if a player has a given permission, as checked by AuthMe.
+ */
+class HasPermissionChecker implements DebugSection {
+
+    static final List<Class<? extends PermissionNode>> PERMISSION_NODE_CLASSES = ImmutableList.of(
+        AdminPermission.class, PlayerPermission.class, PlayerStatePermission.class, DebugSectionPermissions.class);
+
+    @Inject
+    private PermissionsManager permissionsManager;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Override
+    public String getName() {
+        return "perm";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Checks if a player has a given permission";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        sender.sendMessage(ChatColor.BLUE + "AuthMe permission check");
+        if (arguments.size() < 2) {
+            sender.sendMessage("Check if a player has permission:");
+            sender.sendMessage("Example: /authme debug perm bobby my.perm.node");
+            sender.sendMessage("Permission system type used: " + permissionsManager.getPermissionSystem());
+            return;
+        }
+
+        final String playerName = arguments.get(0);
+        final String permissionNode = arguments.get(1);
+
+        Player player = bukkitService.getPlayerExact(playerName);
+        if (player == null) {
+            OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(playerName);
+            if (offlinePlayer == null) {
+                sender.sendMessage(ChatColor.DARK_RED + "Player '" + playerName + "' does not exist");
+            } else {
+                sender.sendMessage("Player '" + playerName + "' not online; checking with offline player");
+                performPermissionCheck(offlinePlayer, permissionNode, permissionsManager::hasPermissionOffline, sender);
+            }
+        } else {
+            performPermissionCheck(player, permissionNode, permissionsManager::hasPermission, sender);
+        }
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.HAS_PERMISSION_CHECK;
+    }
+
+    /**
+     * Performs a permission check and informs the given sender of the result. {@code permissionChecker} is the
+     * permission check to perform with the given {@code node} and the {@code player}.
+     *
+     * @param player the player to check a permission for
+     * @param node the node of the permission to check
+     * @param permissionChecker permission checking function
+     * @param sender the sender to inform of the result
+     * @param <P> the player type
+     */
+    private static <P extends OfflinePlayer> void performPermissionCheck(
+        P player, String node, BiFunction<P, PermissionNode, Boolean> permissionChecker, CommandSender sender) {
+
+        PermissionNode permNode = getPermissionNode(sender, node);
+        if (permissionChecker.apply(player, permNode)) {
+            sender.sendMessage(ChatColor.DARK_GREEN + "Success: player '" + player.getName()
+                + "' has permission '" + node + "'");
+        } else {
+            sender.sendMessage(ChatColor.DARK_RED + "Check failed: player '" + player.getName()
+                + "' does NOT have permission '" + node + "'");
+        }
+    }
+
+    /**
+     * Based on the given permission node (String), tries to find the according AuthMe {@link PermissionNode}
+     * instance, or creates a new one if not available.
+     *
+     * @param sender the sender (used to inform him if no AuthMe PermissionNode can be matched)
+     * @param node the node to search for
+     * @return the node as {@link PermissionNode} object
+     */
+    private static PermissionNode getPermissionNode(CommandSender sender, String node) {
+        Optional<? extends PermissionNode> permNode = PERMISSION_NODE_CLASSES.stream()
+            .map(Class::getEnumConstants)
+            .flatMap(Arrays::stream)
+            .filter(perm -> perm.getNode().equals(node))
+            .findFirst();
+        if (permNode.isPresent()) {
+            return permNode.get();
+        } else {
+            sender.sendMessage("Did not detect AuthMe permission; using default permission = DENIED");
+            return createPermNode(node);
+        }
+    }
+
+    private static PermissionNode createPermNode(String node) {
+        return new PermissionNode() {
+            @Override
+            public String getNode() {
+                return node;
+            }
+
+            @Override
+            public DefaultPermission getDefaultPermission() {
+                return DefaultPermission.NOT_ALLOWED;
+            }
+        };
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/InputValidator.java

@@ -0,0 +1,124 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.listener.FailedVerificationException;
+import fr.xephi.authme.listener.OnJoinVerifier;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.service.ValidationService;
+import fr.xephi.authme.service.ValidationService.ValidationResult;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.Arrays;
+import java.util.List;
+
+import static fr.xephi.authme.command.executable.authme.debug.InputValidator.ValidationObject.MAIL;
+import static fr.xephi.authme.command.executable.authme.debug.InputValidator.ValidationObject.NAME;
+import static fr.xephi.authme.command.executable.authme.debug.InputValidator.ValidationObject.PASS;
+
+/**
+ * Checks if a sample username, email or password is valid according to the AuthMe settings.
+ */
+class InputValidator implements DebugSection {
+
+    @Inject
+    private ValidationService validationService;
+
+    @Inject
+    private Messages messages;
+
+    @Inject
+    private OnJoinVerifier onJoinVerifier;
+
+
+    @Override
+    public String getName() {
+        return "valid";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Checks if your config.yml allows a password / email";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        if (arguments.size() < 2 || !ValidationObject.matchesAny(arguments.get(0))) {
+            displayUsageHint(sender);
+
+        } else if (PASS.matches(arguments.get(0))) {
+            validatePassword(sender, arguments.get(1));
+
+        } else if (MAIL.matches(arguments.get(0))) {
+            validateEmail(sender, arguments.get(1));
+
+        } else if (NAME.matches(arguments.get(0))) {
+            validateUsername(sender, arguments.get(1));
+
+        } else {
+            throw new IllegalStateException("Unexpected validation object with arg[0] = '" + arguments.get(0) + "'");
+        }
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.INPUT_VALIDATOR;
+    }
+
+    private void displayUsageHint(CommandSender sender) {
+        sender.sendMessage(ChatColor.BLUE + "Validation tests");
+        sender.sendMessage("You can define forbidden emails and passwords in your config.yml."
+            + " You can test your settings with this command.");
+        final String command = ChatColor.GOLD + "/authme debug valid";
+        sender.sendMessage(" Use " + command + " pass <pass>" + ChatColor.RESET + " to check a password");
+        sender.sendMessage(" Use " + command + " mail <mail>" + ChatColor.RESET + " to check an email");
+        sender.sendMessage(" Use " + command + " name <name>" + ChatColor.RESET + " to check a username");
+    }
+
+    private void validatePassword(CommandSender sender, String password) {
+        ValidationResult validationResult = validationService.validatePassword(password, "");
+        sender.sendMessage(ChatColor.BLUE + "Validation of password '" + password + "'");
+        if (validationResult.hasError()) {
+            messages.send(sender, validationResult.getMessageKey(), validationResult.getArgs());
+        } else {
+            sender.sendMessage(ChatColor.DARK_GREEN + "Valid password!");
+        }
+    }
+
+    private void validateEmail(CommandSender sender, String email) {
+        boolean isValidEmail = validationService.validateEmail(email);
+        sender.sendMessage(ChatColor.BLUE + "Validation of email '" + email + "'");
+        if (isValidEmail) {
+            sender.sendMessage(ChatColor.DARK_GREEN + "Valid email!");
+        } else {
+            sender.sendMessage(ChatColor.DARK_RED + "Email is not valid!");
+        }
+    }
+
+    private void validateUsername(CommandSender sender, String username) {
+        sender.sendMessage(ChatColor.BLUE + "Validation of username '" + username + "'");
+        try {
+            onJoinVerifier.checkIsValidName(username);
+            sender.sendMessage("Valid username!");
+        } catch (FailedVerificationException failedVerificationEx) {
+            messages.send(sender, failedVerificationEx.getReason(), failedVerificationEx.getArgs());
+        }
+    }
+
+
+    enum ValidationObject {
+
+        PASS, MAIL, NAME;
+
+        static boolean matchesAny(String arg) {
+            return Arrays.stream(values()).anyMatch(vo -> vo.matches(arg));
+        }
+
+        boolean matches(String arg) {
+            return name().equalsIgnoreCase(arg);
+        }
+    }
+
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/LimboPlayerViewer.java

@@ -0,0 +1,143 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.data.limbo.LimboPlayer;
+import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.data.limbo.persistence.LimboPersistence;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.service.BukkitService;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+import static fr.xephi.authme.command.executable.authme.debug.DebugSectionUtils.applyToLimboPlayersMap;
+import static fr.xephi.authme.command.executable.authme.debug.DebugSectionUtils.formatLocation;
+
+/**
+ * Shows the data stored in LimboPlayers and the equivalent properties on online players.
+ */
+class LimboPlayerViewer implements DebugSection {
+
+    @Inject
+    private LimboService limboService;
+
+    @Inject
+    private LimboPersistence limboPersistence;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private PermissionsManager permissionsManager;
+
+    @Override
+    public String getName() {
+        return "limbo";
+    }
+
+    @Override
+    public String getDescription() {
+        return "View LimboPlayers and player's \"limbo stats\"";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        if (arguments.isEmpty()) {
+            sender.sendMessage(ChatColor.BLUE + "AuthMe limbo viewer");
+            sender.sendMessage("/authme debug limbo <player>: show a player's limbo info");
+            sender.sendMessage("Available limbo records: " + applyToLimboPlayersMap(limboService, Map::keySet));
+            return;
+        }
+
+        LimboPlayer memoryLimbo = limboService.getLimboPlayer(arguments.get(0));
+        Player player = bukkitService.getPlayerExact(arguments.get(0));
+        LimboPlayer diskLimbo = player != null ? limboPersistence.getLimboPlayer(player) : null;
+        if (memoryLimbo == null && player == null) {
+            sender.sendMessage(ChatColor.BLUE + "No AuthMe limbo data");
+            sender.sendMessage("No limbo data and no player online with name '" + arguments.get(0) + "'");
+            return;
+        }
+
+        sender.sendMessage(ChatColor.BLUE + "Player / limbo / disk limbo info for '" + arguments.get(0) + "'");
+        new InfoDisplayer(sender, player, memoryLimbo, diskLimbo)
+            .sendEntry("Is op", Player::isOp, LimboPlayer::isOperator)
+            .sendEntry("Walk speed", Player::getWalkSpeed, LimboPlayer::getWalkSpeed)
+            .sendEntry("Can fly", Player::getAllowFlight, LimboPlayer::isCanFly)
+            .sendEntry("Fly speed", Player::getFlySpeed, LimboPlayer::getFlySpeed)
+            .sendEntry("Location", p -> formatLocation(p.getLocation()), l -> formatLocation(l.getLocation()))
+            .sendEntry("Prim. group",
+                p -> permissionsManager.hasGroupSupport() ? permissionsManager.getPrimaryGroup(p) : "N/A",
+                LimboPlayer::getGroups);
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.LIMBO_PLAYER_VIEWER;
+    }
+
+    /**
+     * Displays the info for the given LimboPlayer and Player to the provided CommandSender.
+     */
+    private static final class InfoDisplayer {
+        private final CommandSender sender;
+        private final Optional<Player> player;
+        private final Optional<LimboPlayer> memoryLimbo;
+        private final Optional<LimboPlayer> diskLimbo;
+
+        /**
+         * Constructor.
+         *
+         * @param sender command sender to send the information to
+         * @param player the player to get data from
+         * @param memoryLimbo the limbo player to get data from
+         */
+        InfoDisplayer(CommandSender sender, Player player, LimboPlayer memoryLimbo, LimboPlayer diskLimbo) {
+            this.sender = sender;
+            this.player = Optional.ofNullable(player);
+            this.memoryLimbo = Optional.ofNullable(memoryLimbo);
+            this.diskLimbo = Optional.ofNullable(diskLimbo);
+
+            if (memoryLimbo == null) {
+                sender.sendMessage("Note: no Limbo information available");
+            }
+            if (player == null) {
+                sender.sendMessage("Note: player is not online");
+            } else if (diskLimbo == null) {
+                sender.sendMessage("Note: no Limbo on disk available");
+            }
+        }
+
+        /**
+         * Displays a piece of information to the command sender.
+         *
+         * @param title the designation of the piece of information
+         * @param playerGetter getter for data retrieval on Player
+         * @param limboGetter getter for data retrieval on the LimboPlayer
+         * @param <T> the data type
+         * @return this instance (for chaining)
+         */
+        <T> InfoDisplayer sendEntry(String title,
+                                    Function<Player, T> playerGetter,
+                                    Function<LimboPlayer, T> limboGetter) {
+            sender.sendMessage(
+                title + ": "
+                + getData(player, playerGetter)
+                + " / "
+                + getData(memoryLimbo, limboGetter)
+                + " / "
+                + getData(diskLimbo, limboGetter));
+            return this;
+        }
+
+        static <E, T> String getData(Optional<E> entity, Function<E, T> getter) {
+            return entity.map(getter).map(String::valueOf).orElse(" -- ");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/MySqlDefaultChanger.java

@@ -0,0 +1,327 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import ch.jalu.configme.properties.Property;
+import com.google.common.annotations.VisibleForTesting;
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.datasource.MySQL;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.DatabaseSettings;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static fr.xephi.authme.command.executable.authme.debug.DebugSectionUtils.castToTypeOrNull;
+import static fr.xephi.authme.command.executable.authme.debug.DebugSectionUtils.unwrapSourceFromCacheDataSource;
+import static fr.xephi.authme.data.auth.PlayerAuth.DB_EMAIL_DEFAULT;
+import static fr.xephi.authme.data.auth.PlayerAuth.DB_LAST_IP_DEFAULT;
+import static fr.xephi.authme.data.auth.PlayerAuth.DB_LAST_LOGIN_DEFAULT;
+import static fr.xephi.authme.datasource.SqlDataSourceUtils.getColumnDefaultValue;
+import static fr.xephi.authme.datasource.SqlDataSourceUtils.isNotNullColumn;
+import static java.lang.String.format;
+
+/**
+ * Convenience command to add or remove the default value of a column and its nullable status
+ * in the MySQL data source.
+ */
+class MySqlDefaultChanger implements DebugSection {
+
+    private static final String NOT_NULL_SUFFIX = ChatColor.DARK_AQUA + "@" + ChatColor.RESET;
+    private static final String DEFAULT_VALUE_SUFFIX = ChatColor.GOLD + "#" + ChatColor.RESET;
+
+    private ConsoleLogger logger = ConsoleLoggerFactory.get(MySqlDefaultChanger.class);
+
+    @Inject
+    private Settings settings;
+
+    @Inject
+    private DataSource dataSource;
+
+    private MySQL mySql;
+
+    @PostConstruct
+    void setMySqlField() {
+        this.mySql = castToTypeOrNull(unwrapSourceFromCacheDataSource(this.dataSource), MySQL.class);
+    }
+
+    @Override
+    public String getName() {
+        return "mysqldef";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Add or remove the default value of MySQL columns";
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.MYSQL_DEFAULT_CHANGER;
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        if (mySql == null) {
+            sender.sendMessage("Defaults can be changed for the MySQL data source only.");
+            return;
+        }
+
+        Operation operation = matchToEnum(arguments, 0, Operation.class);
+        Columns column = matchToEnum(arguments, 1, Columns.class);
+        if (operation == Operation.DETAILS) {
+            showColumnDetails(sender);
+        } else if (operation == null || column == null) {
+            displayUsageHints(sender);
+        } else {
+            sender.sendMessage(ChatColor.BLUE + "[AuthMe] MySQL change '" + column + "'");
+            try (Connection con = getConnection(mySql)) {
+                switch (operation) {
+                    case ADD:
+                        changeColumnToNotNullWithDefault(sender, column, con);
+                        break;
+                    case REMOVE:
+                        removeNotNullAndDefault(sender, column, con);
+                        break;
+                    default:
+                        throw new IllegalStateException("Unknown operation '" + operation + "'");
+                }
+            } catch (SQLException | IllegalStateException e) {
+                logger.logException("Failed to perform MySQL default altering operation:", e);
+            }
+        }
+    }
+
+    /**
+     * Adds a default value to the column definition and adds a {@code NOT NULL} constraint for
+     * the specified column.
+     *
+     * @param sender the command sender initiation the action
+     * @param column the column to modify
+     * @param con connection to the database
+     * @throws SQLException .
+     */
+    private void changeColumnToNotNullWithDefault(CommandSender sender, Columns column,
+                                                  Connection con) throws SQLException {
+        final String tableName = settings.getProperty(DatabaseSettings.MYSQL_TABLE);
+        final String columnName = settings.getProperty(column.getColumnNameProperty());
+
+        // Replace NULLs with future default value
+        String sql = format("UPDATE %s SET %s = ? WHERE %s IS NULL;", tableName, columnName, columnName);
+        int updatedRows;
+        try (PreparedStatement pst = con.prepareStatement(sql)) {
+            pst.setObject(1, column.getDefaultValue());
+            updatedRows = pst.executeUpdate();
+        }
+        sender.sendMessage("Replaced NULLs with default value ('" + column.getDefaultValue()
+            + "'), modifying " + updatedRows + " entries");
+
+        // Change column definition to NOT NULL version
+        try (Statement st = con.createStatement()) {
+            st.execute(format("ALTER TABLE %s MODIFY %s %s", tableName, columnName, column.getNotNullDefinition()));
+            sender.sendMessage("Changed column '" + columnName + "' to have NOT NULL constraint");
+        }
+
+        // Log success message
+        logger.info("Changed MySQL column '" + columnName + "' to be NOT NULL, as initiated by '"
+            + sender.getName() + "'");
+    }
+
+    /**
+     * Removes the {@code NOT NULL} constraint of a column definition and replaces rows with the
+     * default value to {@code NULL}.
+     *
+     * @param sender the command sender initiation the action
+     * @param column the column to modify
+     * @param con connection to the database
+     * @throws SQLException .
+     */
+    private void removeNotNullAndDefault(CommandSender sender, Columns column, Connection con) throws SQLException {
+        final String tableName = settings.getProperty(DatabaseSettings.MYSQL_TABLE);
+        final String columnName = settings.getProperty(column.getColumnNameProperty());
+
+        // Change column definition to nullable version
+        try (Statement st = con.createStatement()) {
+            st.execute(format("ALTER TABLE %s MODIFY %s %s", tableName, columnName, column.getNullableDefinition()));
+            sender.sendMessage("Changed column '" + columnName + "' to allow nulls");
+        }
+
+        // Replace old default value with NULL
+        String sql = format("UPDATE %s SET %s = NULL WHERE %s = ?;", tableName, columnName, columnName);
+        int updatedRows;
+        try (PreparedStatement pst = con.prepareStatement(sql)) {
+            pst.setObject(1, column.getDefaultValue());
+            updatedRows = pst.executeUpdate();
+        }
+        sender.sendMessage("Replaced default value ('" + column.getDefaultValue()
+            + "') to be NULL, modifying " + updatedRows + " entries");
+
+        // Log success message
+        logger.info("Changed MySQL column '" + columnName + "' to allow NULL, as initiated by '"
+            + sender.getName() + "'");
+    }
+
+    /**
+     * Outputs the current definitions of all {@link Columns} which can be migrated.
+     *
+     * @param sender command sender to output the data to
+     */
+    private void showColumnDetails(CommandSender sender) {
+        sender.sendMessage(ChatColor.BLUE + "MySQL column details");
+        final String tableName = settings.getProperty(DatabaseSettings.MYSQL_TABLE);
+        try (Connection con = getConnection(mySql)) {
+            final DatabaseMetaData metaData = con.getMetaData();
+            for (Columns col : Columns.values()) {
+                String columnName = settings.getProperty(col.getColumnNameProperty());
+                String isNullText = isNotNullColumn(metaData, tableName, columnName) ? "NOT NULL" : "nullable";
+                Object defaultValue = getColumnDefaultValue(metaData, tableName, columnName);
+                String defaultText = defaultValue == null ? "no default" : "default: '" + defaultValue + "'";
+                sender.sendMessage(formatColumnWithMetadata(col, metaData, tableName)
+                    + " (" + columnName + "): " + isNullText + ", " + defaultText);
+            }
+        } catch (SQLException e) {
+            logger.logException("Failed while showing column details:", e);
+            sender.sendMessage("Failed while showing column details. See log for info");
+        }
+
+    }
+
+    /**
+     * Displays sample commands and the list of columns that can be changed.
+     *
+     * @param sender the sender issuing the command
+     */
+    private void displayUsageHints(CommandSender sender) {
+        sender.sendMessage(ChatColor.BLUE + "MySQL column changer");
+        sender.sendMessage("Adds or removes a NOT NULL constraint for a column.");
+        sender.sendMessage("Examples: add a NOT NULL constraint with");
+        sender.sendMessage(" /authme debug mysqldef add <column>");
+        sender.sendMessage("Remove one with /authme debug mysqldef remove <column>");
+
+        sender.sendMessage("Available columns: " + constructColumnListWithMetadata());
+        sender.sendMessage(" " + NOT_NULL_SUFFIX + ": not-null, " + DEFAULT_VALUE_SUFFIX
+            + ": has default. See /authme debug mysqldef details");
+    }
+
+    /**
+     * @return list of {@link Columns} we can toggle with suffixes indicating their NOT NULL and default value status
+     */
+    private String constructColumnListWithMetadata() {
+        try (Connection con = getConnection(mySql)) {
+            final DatabaseMetaData metaData = con.getMetaData();
+            final String tableName = settings.getProperty(DatabaseSettings.MYSQL_TABLE);
+
+            List<String> formattedColumns = new ArrayList<>(Columns.values().length);
+            for (Columns col : Columns.values()) {
+                formattedColumns.add(formatColumnWithMetadata(col, metaData, tableName));
+            }
+            return String.join(ChatColor.RESET + ", ", formattedColumns);
+        } catch (SQLException e) {
+            logger.logException("Failed to construct column list:", e);
+            return ChatColor.RED + "An error occurred! Please see the console for details.";
+        }
+    }
+
+    private String formatColumnWithMetadata(Columns column, DatabaseMetaData metaData,
+                                            String tableName) throws SQLException {
+        String columnName = settings.getProperty(column.getColumnNameProperty());
+        boolean isNotNull = isNotNullColumn(metaData, tableName, columnName);
+        boolean hasDefaultValue = getColumnDefaultValue(metaData, tableName, columnName) != null;
+        return column.name()
+            + (isNotNull ? NOT_NULL_SUFFIX : "")
+            + (hasDefaultValue ? DEFAULT_VALUE_SUFFIX : "");
+    }
+
+    /**
+     * Gets the Connection object from the MySQL data source.
+     *
+     * @param mySql the MySQL data source to get the connection from
+     * @return the connection
+     */
+    @VisibleForTesting
+    Connection getConnection(MySQL mySql) {
+        try {
+            Method method = MySQL.class.getDeclaredMethod("getConnection");
+            method.setAccessible(true);
+            return (Connection) method.invoke(mySql);
+        } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
+            throw new IllegalStateException("Could not get MySQL connection", e);
+        }
+    }
+
+    private static <E extends Enum<E>> E matchToEnum(List<String> arguments, int index, Class<E> clazz) {
+        if (arguments.size() <= index) {
+            return null;
+        }
+        String str = arguments.get(index);
+        return Arrays.stream(clazz.getEnumConstants())
+            .filter(e -> e.name().equalsIgnoreCase(str))
+            .findFirst().orElse(null);
+    }
+
+    private enum Operation {
+        ADD, REMOVE, DETAILS
+    }
+
+    /** MySQL columns which can be toggled between being NOT NULL and allowing NULL values. */
+    enum Columns {
+
+        LASTLOGIN(DatabaseSettings.MYSQL_COL_LASTLOGIN,
+            "BIGINT", "BIGINT NOT NULL DEFAULT 0", DB_LAST_LOGIN_DEFAULT),
+
+        LASTIP(DatabaseSettings.MYSQL_COL_LAST_IP,
+            "VARCHAR(40) CHARACTER SET ascii COLLATE ascii_bin",
+            "VARCHAR(40) CHARACTER SET ascii COLLATE ascii_bin NOT NULL DEFAULT '127.0.0.1'",
+            DB_LAST_IP_DEFAULT),
+
+        EMAIL(DatabaseSettings.MYSQL_COL_EMAIL,
+            "VARCHAR(255)", "VARCHAR(255) NOT NULL DEFAULT 'your@email.com'", DB_EMAIL_DEFAULT);
+
+        private final Property<String> columnNameProperty;
+        private final String nullableDefinition;
+        private final String notNullDefinition;
+        private final Object defaultValue;
+
+        Columns(Property<String> columnNameProperty, String nullableDefinition,
+                String notNullDefinition, Object defaultValue) {
+            this.columnNameProperty = columnNameProperty;
+            this.nullableDefinition = nullableDefinition;
+            this.notNullDefinition = notNullDefinition;
+            this.defaultValue = defaultValue;
+        }
+
+        /** @return property defining the column name in the database */
+        Property<String> getColumnNameProperty() {
+            return columnNameProperty;
+        }
+
+        /** @return SQL definition of the column allowing NULL values */
+        String getNullableDefinition() {
+            return nullableDefinition;
+        }
+
+        /** @return SQL definition of the column with a NOT NULL constraint */
+        String getNotNullDefinition() {
+            return notNullDefinition;
+        }
+
+        /** @return the default value used in {@link #notNullDefinition} */
+        Object getDefaultValue() {
+            return defaultValue;
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/PermissionGroups.java

@@ -0,0 +1,56 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.data.limbo.UserGroup;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsManager;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * Outputs the permission groups of a player.
+ */
+class PermissionGroups implements DebugSection {
+
+    @Inject
+    private PermissionsManager permissionsManager;
+
+    @Override
+    public String getName() {
+        return "groups";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Show permission groups a player belongs to";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        sender.sendMessage(ChatColor.BLUE + "AuthMe permission groups");
+        String name = arguments.isEmpty() ? sender.getName() : arguments.get(0);
+        Player player = Bukkit.getPlayer(name);
+        if (player == null) {
+            sender.sendMessage("Player " + name + " could not be found");
+        } else {
+            List<String> groupNames = permissionsManager.getGroups(player).stream()
+                .map(UserGroup::getGroupName)
+                .collect(toList());
+
+            sender.sendMessage("Player " + name + " has permission groups: " + String.join(", ", groupNames));
+            sender.sendMessage("Primary group is: " + permissionsManager.getGroups(player));
+        }
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.PERM_GROUPS;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/PlayerAuthViewer.java

@@ -0,0 +1,117 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.security.crypts.HashedPassword;
+import fr.xephi.authme.util.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import static fr.xephi.authme.command.executable.authme.debug.DebugSectionUtils.formatLocation;
+
+/**
+ * Allows to view the data of a PlayerAuth in the database.
+ */
+class PlayerAuthViewer implements DebugSection {
+
+    @Inject
+    private DataSource dataSource;
+
+    @Override
+    public String getName() {
+        return "db";
+    }
+
+    @Override
+    public String getDescription() {
+        return "View player's data in the database";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        if (arguments.isEmpty()) {
+            sender.sendMessage(ChatColor.BLUE + "AuthMe database viewer");
+            sender.sendMessage("Enter player name to view his data in the database.");
+            sender.sendMessage("Example: /authme debug db Bobby");
+            return;
+        }
+
+        PlayerAuth auth = dataSource.getAuth(arguments.get(0));
+        if (auth == null) {
+            sender.sendMessage(ChatColor.BLUE + "AuthMe database viewer");
+            sender.sendMessage("No record exists for '" + arguments.get(0) + "'");
+        } else {
+            displayAuthToSender(auth, sender);
+        }
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.PLAYER_AUTH_VIEWER;
+    }
+
+    /**
+     * Outputs the PlayerAuth information to the given sender.
+     *
+     * @param auth the PlayerAuth to display
+     * @param sender the sender to send the messages to
+     */
+    private void displayAuthToSender(PlayerAuth auth, CommandSender sender) {
+        sender.sendMessage(ChatColor.BLUE + "[AuthMe] Player " + auth.getNickname() + " / " + auth.getRealName());
+        sender.sendMessage("Email: " + auth.getEmail() + ". IP: " + auth.getLastIp() + ". Group: " + auth.getGroupId());
+        sender.sendMessage("Quit location: "
+            + formatLocation(auth.getQuitLocX(), auth.getQuitLocY(), auth.getQuitLocZ(), auth.getWorld()));
+        sender.sendMessage("Last login: " + formatDate(auth.getLastLogin()));
+        sender.sendMessage("Registration: " + formatDate(auth.getRegistrationDate())
+            + " with IP " + auth.getRegistrationIp());
+
+        HashedPassword hashedPass = auth.getPassword();
+        sender.sendMessage("Hash / salt (partial): '" + safeSubstring(hashedPass.getHash(), 6)
+            + "' / '" + safeSubstring(hashedPass.getSalt(), 4) + "'");
+        sender.sendMessage("TOTP code (partial): '" + safeSubstring(auth.getTotpKey(), 3) + "'");
+    }
+
+    /**
+     * Fail-safe substring method. Guarantees not to show the entire String.
+     *
+     * @param str the string to transform
+     * @param length number of characters to show from the start of the String
+     * @return the first <code>length</code> characters of the string, or half of the string if it is shorter,
+     *         or empty string if the string is null or empty
+     */
+    private static String safeSubstring(String str, int length) {
+        if (StringUtils.isBlank(str)) {
+            return "";
+        } else if (str.length() < length) {
+            return str.substring(0, str.length() / 2) + "...";
+        } else {
+            return str.substring(0, length) + "...";
+        }
+    }
+
+    /**
+     * Formats the given timestamp to a human readable date.
+     *
+     * @param timestamp the timestamp to format (nullable)
+     * @return the formatted timestamp
+     */
+    private static String formatDate(Long timestamp) {
+        if (timestamp == null) {
+            return "Not available (null)";
+        } else if (timestamp == 0) {
+            return "Not available (0)";
+        } else {
+            LocalDateTime date = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
+            return DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(date);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/SpawnLocationViewer.java

@@ -0,0 +1,87 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.SpawnLoader;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+import static fr.xephi.authme.command.executable.authme.debug.DebugSectionUtils.formatLocation;
+
+/**
+ * Shows the spawn location that AuthMe is configured to use.
+ */
+class SpawnLocationViewer implements DebugSection {
+
+    @Inject
+    private SpawnLoader spawnLoader;
+
+    @Inject
+    private Settings settings;
+
+    @Inject
+    private BukkitService bukkitService;
+
+
+    @Override
+    public String getName() {
+        return "spawn";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Shows the spawn location that AuthMe will use";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        sender.sendMessage(ChatColor.BLUE + "AuthMe spawn location viewer");
+        if (arguments.isEmpty()) {
+            showGeneralInfo(sender);
+        } else if ("?".equals(arguments.get(0))) {
+            showHelp(sender);
+        } else {
+            showPlayerSpawn(sender, arguments.get(0));
+        }
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.SPAWN_LOCATION;
+    }
+
+    private void showGeneralInfo(CommandSender sender) {
+        sender.sendMessage("Spawn priority: "
+            + String.join(", ", settings.getProperty(RestrictionSettings.SPAWN_PRIORITY)));
+        sender.sendMessage("AuthMe spawn location: " + formatLocation(spawnLoader.getSpawn()));
+        sender.sendMessage("AuthMe first spawn location: " + formatLocation(spawnLoader.getFirstSpawn()));
+        sender.sendMessage("AuthMe (first)spawn are only used depending on the configured priority!");
+        sender.sendMessage("Use '/authme debug spawn ?' for further help");
+    }
+
+    private void showHelp(CommandSender sender) {
+        sender.sendMessage("Use /authme spawn and /authme firstspawn to teleport to the spawns.");
+        sender.sendMessage("/authme set(first)spawn sets the (first) spawn to your current location.");
+        sender.sendMessage("Use /authme debug spawn <player> to view where a player would be teleported to.");
+        sender.sendMessage("Read more at https://github.com/AuthMe/AuthMeReloaded/wiki/Spawn-Handling");
+    }
+
+    private void showPlayerSpawn(CommandSender sender, String playerName) {
+        Player player = bukkitService.getPlayerExact(playerName);
+        if (player == null) {
+            sender.sendMessage("Player '" + playerName + "' is not online!");
+        } else {
+            Location spawn = spawnLoader.getSpawnLocation(player);
+            sender.sendMessage("Player '" + playerName + "' has spawn location: " + formatLocation(spawn));
+            sender.sendMessage("Note: this check excludes the AuthMe firstspawn.");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/authme/debug/TestEmailSender.java

@@ -0,0 +1,125 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import ch.jalu.datasourcecolumns.data.DataSourceValue;
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.mail.SendMailSsl;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.util.StringUtils;
+import fr.xephi.authme.util.Utils;
+import org.apache.commons.mail.EmailException;
+import org.apache.commons.mail.HtmlEmail;
+import org.bukkit.ChatColor;
+import org.bukkit.Server;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Sends out a test email.
+ */
+class TestEmailSender implements DebugSection {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(TestEmailSender.class);
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private SendMailSsl sendMailSsl;
+
+    @Inject
+    private Server server;
+
+
+    @Override
+    public String getName() {
+        return "mail";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Sends out a test email";
+    }
+
+    @Override
+    public void execute(CommandSender sender, List<String> arguments) {
+        sender.sendMessage(ChatColor.BLUE + "AuthMe test email sender");
+        if (!sendMailSsl.hasAllInformation()) {
+            sender.sendMessage(ChatColor.RED + "You haven't set all required configurations in config.yml "
+                + "for sending emails. Please check your config.yml");
+            return;
+        }
+
+        String email = getEmail(sender, arguments);
+
+        // getEmail() takes care of informing the sender of the error if email == null
+        if (email != null) {
+            boolean sendMail = sendTestEmail(email);
+            if (sendMail) {
+                sender.sendMessage("Test email sent to " + email + " with success");
+            } else {
+                sender.sendMessage(ChatColor.RED + "Failed to send test mail to " + email + "; please check your logs");
+            }
+        }
+    }
+
+    @Override
+    public PermissionNode getRequiredPermission() {
+        return DebugSectionPermissions.TEST_EMAIL;
+    }
+
+    /**
+     * Gets the email address to use based on the sender and the arguments. If the arguments are empty,
+     * we attempt to retrieve the email from the sender. If there is an argument, we verify that it is
+     * an email address.
+     * {@code null} is returned if no email address could be found. This method informs the sender of
+     * the specific error in such cases.
+     *
+     * @param sender the command sender
+     * @param arguments the provided arguments
+     * @return the email to use, or null if none found
+     */
+    private String getEmail(CommandSender sender, List<String> arguments) {
+        if (arguments.isEmpty()) {
+            DataSourceValue<String> emailResult = dataSource.getEmail(sender.getName());
+            if (!emailResult.rowExists()) {
+                sender.sendMessage(ChatColor.RED + "Please provide an email address, "
+                    + "e.g. /authme debug mail test@example.com");
+                return null;
+            }
+            final String email = emailResult.getValue();
+            if (Utils.isEmailEmpty(email)) {
+                sender.sendMessage(ChatColor.RED + "No email set for your account!"
+                    + " Please use /authme debug mail <email>");
+                return null;
+            }
+            return email;
+        } else {
+            String email = arguments.get(0);
+            if (StringUtils.isInsideString('@', email)) {
+                return email;
+            }
+            sender.sendMessage(ChatColor.RED + "Invalid email! Usage: /authme debug mail test@example.com");
+            return null;
+        }
+    }
+
+    private boolean sendTestEmail(String email) {
+        HtmlEmail htmlEmail;
+        try {
+            htmlEmail = sendMailSsl.initializeMail(email);
+        } catch (EmailException e) {
+            logger.logException("Failed to create email for sample email:", e);
+            return false;
+        }
+
+        htmlEmail.setSubject("AuthMe test email");
+        String message = "Hello there!<br />This is a sample email sent to you from a Minecraft server ("
+            + server.getName() + ") via /authme debug mail. If you're seeing this, sending emails should be fine.";
+        return sendMailSsl.sendEmail(message, htmlEmail);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/captcha/CaptchaCommand.java

@@ -0,0 +1,86 @@
+package fr.xephi.authme.command.executable.captcha;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.data.captcha.LoginCaptchaManager;
+import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
+import fr.xephi.authme.data.limbo.LimboMessageType;
+import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Captcha command, allowing a player to solve a captcha.
+ */
+public class CaptchaCommand extends PlayerCommand {
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private LoginCaptchaManager loginCaptchaManager;
+
+    @Inject
+    private RegistrationCaptchaManager registrationCaptchaManager;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private LimboService limboService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        final String name = player.getName();
+
+        if (playerCache.isAuthenticated(name)) {
+            // No captcha is relevant if the player is logged in
+            commonService.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
+            return;
+        }
+
+        if (loginCaptchaManager.isCaptchaRequired(name)) {
+            checkLoginCaptcha(player, arguments.get(0));
+        } else {
+            final boolean isPlayerRegistered = dataSource.isAuthAvailable(name);
+            if (!isPlayerRegistered && registrationCaptchaManager.isCaptchaRequired(name)) {
+                checkRegisterCaptcha(player, arguments.get(0));
+            } else {
+                MessageKey errorMessage = isPlayerRegistered ? MessageKey.USAGE_LOGIN : MessageKey.USAGE_REGISTER;
+                commonService.send(player, errorMessage);
+            }
+        }
+    }
+
+    private void checkLoginCaptcha(Player player, String captchaCode) {
+        final boolean isCorrectCode = loginCaptchaManager.checkCode(player, captchaCode);
+        if (isCorrectCode) {
+            commonService.send(player, MessageKey.CAPTCHA_SUCCESS);
+            commonService.send(player, MessageKey.LOGIN_MESSAGE);
+            limboService.unmuteMessageTask(player);
+        } else {
+            String newCode = loginCaptchaManager.getCaptchaCodeOrGenerateNew(player.getName());
+            commonService.send(player, MessageKey.CAPTCHA_WRONG_ERROR, newCode);
+        }
+    }
+
+    private void checkRegisterCaptcha(Player player, String captchaCode) {
+        final boolean isCorrectCode = registrationCaptchaManager.checkCode(player, captchaCode);
+        if (isCorrectCode) {
+            commonService.send(player, MessageKey.REGISTER_CAPTCHA_SUCCESS);
+            commonService.send(player, MessageKey.REGISTER_MESSAGE);
+        } else {
+            String newCode = registrationCaptchaManager.getCaptchaCodeOrGenerateNew(player.getName());
+            commonService.send(player, MessageKey.CAPTCHA_WRONG_ERROR, newCode);
+        }
+        limboService.resetMessageTask(player, LimboMessageType.REGISTER);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/changepassword/ChangePasswordCommand.java

@@ -0,0 +1,74 @@
+package fr.xephi.authme.command.executable.changepassword;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.VerificationCodeManager;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.ValidationService;
+import fr.xephi.authme.service.ValidationService.ValidationResult;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * The command for a player to change his password with.
+ */
+public class ChangePasswordCommand extends PlayerCommand {
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private ValidationService validationService;
+
+    @Inject
+    private Management management;
+
+    @Inject
+    private VerificationCodeManager codeManager;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        String name = player.getName().toLowerCase(Locale.ROOT);
+
+        if (!playerCache.isAuthenticated(name)) {
+            commonService.send(player, MessageKey.NOT_LOGGED_IN);
+            return;
+        }
+        // Check if the user has been verified or not
+        if (codeManager.isVerificationRequired(player)) {
+            codeManager.codeExistOrGenerateNew(name);
+            commonService.send(player, MessageKey.VERIFICATION_CODE_REQUIRED);
+            return;
+        }
+
+        String oldPassword = arguments.get(0);
+        String newPassword = arguments.get(1);
+
+        // Make sure the password is allowed
+        ValidationResult passwordValidation = validationService.validatePassword(newPassword, name);
+        if (passwordValidation.hasError()) {
+            commonService.send(player, passwordValidation.getMessageKey(), passwordValidation.getArgs());
+            return;
+        }
+
+        management.performPasswordChange(player, oldPassword, newPassword);
+    }
+
+    @Override
+    protected String getAlternativeCommand() {
+        return "/authme password <playername> <password>";
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_CHANGE_PASSWORD;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/email/AddEmailCommand.java

@@ -0,0 +1,40 @@
+package fr.xephi.authme.command.executable.email;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command for setting an email to an account.
+ */
+public class AddEmailCommand extends PlayerCommand {
+
+    @Inject
+    private Management management;
+
+    @Inject
+    private CommonService commonService;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        String email = arguments.get(0);
+        String emailConfirmation = arguments.get(1);
+
+        if (email.equals(emailConfirmation)) {
+            // Closer inspection of the mail address handled by the async task
+            management.performAddEmail(player, email);
+        } else {
+            commonService.send(player, MessageKey.CONFIRM_EMAIL_MESSAGE);
+        }
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_ADD_EMAIL;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/email/ChangeEmailCommand.java

@@ -0,0 +1,46 @@
+package fr.xephi.authme.command.executable.email;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.VerificationCodeManager;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Change email command.
+ */
+public class ChangeEmailCommand extends PlayerCommand {
+
+    @Inject
+    private Management management;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private VerificationCodeManager codeManager;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        final String playerName = player.getName();
+        // Check if the user has been verified or not
+        if (codeManager.isVerificationRequired(player)) {
+            codeManager.codeExistOrGenerateNew(playerName);
+            commonService.send(player, MessageKey.VERIFICATION_CODE_REQUIRED);
+            return;
+        }
+
+        String playerMailOld = arguments.get(0);
+        String playerMailNew = arguments.get(1);
+        management.performChangeEmail(player, playerMailOld, playerMailNew);
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_CHANGE_EMAIL;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/email/EmailBaseCommand.java

@@ -0,0 +1,29 @@
+package fr.xephi.authme.command.executable.email;
+
+import fr.xephi.authme.command.CommandMapper;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.command.FoundCommandResult;
+import fr.xephi.authme.command.help.HelpProvider;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Base command for /email, showing information about the child commands.
+ */
+public class EmailBaseCommand implements ExecutableCommand {
+
+    @Inject
+    private CommandMapper commandMapper;
+
+    @Inject
+    private HelpProvider helpProvider;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        FoundCommandResult result = commandMapper.mapPartsToCommand(sender, Collections.singletonList("email"));
+        helpProvider.outputHelp(sender, result, HelpProvider.SHOW_CHILDREN);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/email/EmailSetPasswordCommand.java

@@ -0,0 +1,61 @@
+package fr.xephi.authme.command.executable.email;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.security.PasswordSecurity;
+import fr.xephi.authme.security.crypts.HashedPassword;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.PasswordRecoveryService;
+import fr.xephi.authme.service.ValidationService;
+import fr.xephi.authme.service.ValidationService.ValidationResult;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command for changing password following successful recovery.
+ */
+public class EmailSetPasswordCommand extends PlayerCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(EmailSetPasswordCommand.class);
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private PasswordRecoveryService recoveryService;
+
+    @Inject
+    private PasswordSecurity passwordSecurity;
+
+    @Inject
+    private ValidationService validationService;
+
+    @Override
+    protected void runCommand(Player player, List<String> arguments) {
+        if (recoveryService.canChangePassword(player)) {
+            String name = player.getName();
+            String password = arguments.get(0);
+
+            ValidationResult result = validationService.validatePassword(password, name);
+            if (!result.hasError()) {
+                HashedPassword hashedPassword = passwordSecurity.computeHash(password, name);
+                dataSource.updatePassword(name, hashedPassword);
+                recoveryService.removeFromSuccessfulRecovery(player);
+                logger.info("Player '" + name + "' has changed their password from recovery");
+                commonService.send(player, MessageKey.PASSWORD_CHANGED_SUCCESS);
+            } else {
+                commonService.send(player, result.getMessageKey(), result.getArgs());
+            }
+        } else {
+            commonService.send(player, MessageKey.CHANGE_PASSWORD_EXPIRED);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/email/ProcessCodeCommand.java

@@ -0,0 +1,46 @@
+package fr.xephi.authme.command.executable.email;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.PasswordRecoveryService;
+import fr.xephi.authme.service.RecoveryCodeService;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command for submitting email recovery code.
+ */
+public class ProcessCodeCommand extends PlayerCommand {
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private RecoveryCodeService codeService;
+
+    @Inject
+    private PasswordRecoveryService recoveryService;
+
+    @Override
+    protected void runCommand(Player player, List<String> arguments) {
+        String name = player.getName();
+        String code = arguments.get(0);
+
+        if (codeService.hasTriesLeft(name)) {
+            if (codeService.isCodeValid(name, code)) {
+                commonService.send(player, MessageKey.RECOVERY_CODE_CORRECT);
+                recoveryService.addSuccessfulRecovery(player);
+                codeService.removeCode(name);
+            } else {
+                commonService.send(player, MessageKey.INCORRECT_RECOVERY_CODE,
+                    Integer.toString(codeService.getTriesLeft(name)));
+            }
+        } else {
+            codeService.removeCode(name);
+            commonService.send(player, MessageKey.RECOVERY_TRIES_EXCEEDED);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/email/RecoverEmailCommand.java

@@ -0,0 +1,91 @@
+package fr.xephi.authme.command.executable.email;
+
+import ch.jalu.datasourcecolumns.data.DataSourceValue;
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.mail.EmailService;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.PasswordRecoveryService;
+import fr.xephi.authme.service.RecoveryCodeService;
+import fr.xephi.authme.util.Utils;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command for password recovery by email.
+ */
+public class RecoverEmailCommand extends PlayerCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(RecoverEmailCommand.class);
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private EmailService emailService;
+
+    @Inject
+    private PasswordRecoveryService recoveryService;
+
+    @Inject
+    private RecoveryCodeService recoveryCodeService;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Override
+    protected void runCommand(Player player, List<String> arguments) {
+        final String playerMail = arguments.get(0);
+        final String playerName = player.getName();
+
+        if (!emailService.hasAllInformation()) {
+            logger.warning("Mail API is not set");
+            commonService.send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
+            return;
+        }
+        if (playerCache.isAuthenticated(playerName)) {
+            commonService.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
+            return;
+        }
+
+        DataSourceValue<String> emailResult = dataSource.getEmail(playerName);
+        if (!emailResult.rowExists()) {
+            commonService.send(player, MessageKey.USAGE_REGISTER);
+            return;
+        }
+
+        final String email = emailResult.getValue();
+        if (Utils.isEmailEmpty(email) || !email.equalsIgnoreCase(playerMail)) {
+            commonService.send(player, MessageKey.INVALID_EMAIL);
+            return;
+        }
+
+        bukkitService.runTaskAsynchronously(() -> {
+            if (recoveryCodeService.isRecoveryCodeNeeded()) {
+                // Recovery code is needed; generate and send one
+                recoveryService.createAndSendRecoveryCode(player, email);
+            } else {
+                // Code not needed, just send them a new password
+                recoveryService.generateAndSendNewPassword(player, email);
+            }
+        });
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_RECOVER_EMAIL;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/email/ShowEmailCommand.java

@@ -0,0 +1,48 @@
+package fr.xephi.authme.command.executable.email;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.settings.properties.SecuritySettings;
+import fr.xephi.authme.util.Utils;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Show email command.
+ */
+public class ShowEmailCommand extends PlayerCommand {
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        PlayerAuth auth = playerCache.getAuth(player.getName());
+        if (auth != null && !Utils.isEmailEmpty(auth.getEmail())) {
+            if (commonService.getProperty(SecuritySettings.USE_EMAIL_MASKING)){
+                commonService.send(player, MessageKey.EMAIL_SHOW, emailMask(auth.getEmail()));
+            } else {
+                commonService.send(player, MessageKey.EMAIL_SHOW, auth.getEmail());
+            }
+        } else {
+            commonService.send(player, MessageKey.SHOW_NO_EMAIL);
+        }
+    }
+
+    private String emailMask(String email){
+        String[] frag = email.split("@");   //Split id and domain
+        int sid = frag[0].length() / 3 + 1;     //Define the id view (required length >= 1)
+        int sdomain = frag[1].length() / 3;   //Define the domain view (required length >= 0)
+        String id = frag[0].substring(0, sid) + "***";  //Build the id
+        String domain = "***" + frag[1].substring(sdomain);  //Build the domain
+        return id + "@" + domain;
+    }
+}

src/main/java/fr/xephi/authme/command/executable/login/LoginCommand.java

@@ -0,0 +1,34 @@
+package fr.xephi.authme.command.executable.login;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.process.Management;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Login command.
+ */
+public class LoginCommand extends PlayerCommand {
+
+    @Inject
+    private Management management;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        String password = arguments.get(0);
+        management.performLogin(player, password);
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_LOGIN;
+    }
+
+    @Override
+    protected String getAlternativeCommand() {
+        return "/authme forcelogin <player>";
+    }
+}

src/main/java/fr/xephi/authme/command/executable/logout/LogoutCommand.java

@@ -0,0 +1,22 @@
+package fr.xephi.authme.command.executable.logout;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.process.Management;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Logout command.
+ */
+public class LogoutCommand extends PlayerCommand {
+
+    @Inject
+    private Management management;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        management.performLogout(player);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java

@@ -0,0 +1,225 @@
+package fr.xephi.authme.command.executable.register;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.mail.EmailService;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.process.register.RegisterSecondaryArgument;
+import fr.xephi.authme.process.register.RegistrationType;
+import fr.xephi.authme.process.register.executors.EmailRegisterParams;
+import fr.xephi.authme.process.register.executors.PasswordRegisterParams;
+import fr.xephi.authme.process.register.executors.RegistrationMethod;
+import fr.xephi.authme.process.register.executors.TwoFactorRegisterParams;
+import fr.xephi.authme.security.HashAlgorithm;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.service.ValidationService;
+import fr.xephi.authme.settings.properties.EmailSettings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.SecuritySettings;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import static fr.xephi.authme.process.register.RegisterSecondaryArgument.CONFIRMATION;
+import static fr.xephi.authme.process.register.RegisterSecondaryArgument.EMAIL_MANDATORY;
+import static fr.xephi.authme.process.register.RegisterSecondaryArgument.EMAIL_OPTIONAL;
+import static fr.xephi.authme.process.register.RegisterSecondaryArgument.NONE;
+import static fr.xephi.authme.settings.properties.RegistrationSettings.REGISTER_SECOND_ARGUMENT;
+
+/**
+ * Command for /register.
+ */
+public class RegisterCommand extends PlayerCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(RegisterCommand.class);
+
+    @Inject
+    private Management management;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private EmailService emailService;
+
+    @Inject
+    private ValidationService validationService;
+
+    @Inject
+    private RegistrationCaptchaManager registrationCaptchaManager;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        if (!isCaptchaFulfilled(player)) {
+            return; // isCaptchaFulfilled handles informing the player on failure
+        }
+
+        if (commonService.getProperty(SecuritySettings.PASSWORD_HASH) == HashAlgorithm.TWO_FACTOR) {
+            //for two factor auth we don't need to check the usage
+            management.performRegister(RegistrationMethod.TWO_FACTOR_REGISTRATION,
+                TwoFactorRegisterParams.of(player));
+            return;
+        } else if (arguments.size() < 1) {
+            commonService.send(player, MessageKey.USAGE_REGISTER);
+            return;
+        }
+
+        RegistrationType registrationType = commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE);
+        if (registrationType == RegistrationType.PASSWORD) {
+            handlePasswordRegistration(player, arguments);
+        } else if (registrationType == RegistrationType.EMAIL) {
+            handleEmailRegistration(player, arguments);
+        } else {
+            throw new IllegalStateException("Unknown registration type '" + registrationType + "'");
+        }
+    }
+
+    @Override
+    protected String getAlternativeCommand() {
+        return "/authme register <playername> <password>";
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_REGISTER;
+    }
+
+    private boolean isCaptchaFulfilled(Player player) {
+        if (registrationCaptchaManager.isCaptchaRequired(player.getName())) {
+            String code = registrationCaptchaManager.getCaptchaCodeOrGenerateNew(player.getName());
+            commonService.send(player, MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, code);
+            return false;
+        }
+        return true;
+    }
+
+    private void handlePasswordRegistration(Player player, List<String> arguments) {
+        if (isSecondArgValidForPasswordRegistration(player, arguments)) {
+            final String password = arguments.get(0);
+            final String email = getEmailIfAvailable(arguments);
+
+            management.performRegister(RegistrationMethod.PASSWORD_REGISTRATION,
+                PasswordRegisterParams.of(player, password, email));
+        }
+    }
+
+    private String getEmailIfAvailable(List<String> arguments) {
+        if (arguments.size() >= 2) {
+            RegisterSecondaryArgument secondArgType = commonService.getProperty(REGISTER_SECOND_ARGUMENT);
+            if (secondArgType == EMAIL_MANDATORY || secondArgType == EMAIL_OPTIONAL) {
+                return arguments.get(1);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Verifies that the second argument is valid (based on the configuration)
+     * to perform a password registration. The player is informed if the check
+     * is unsuccessful.
+     *
+     * @param player the player to register
+     * @param arguments the provided arguments
+     * @return true if valid, false otherwise
+     */
+    private boolean isSecondArgValidForPasswordRegistration(Player player, List<String> arguments) {
+        RegisterSecondaryArgument secondArgType = commonService.getProperty(REGISTER_SECOND_ARGUMENT);
+        // cases where args.size < 2
+        if (secondArgType == NONE || secondArgType == EMAIL_OPTIONAL && arguments.size() < 2) {
+            return true;
+        } else if (arguments.size() < 2) {
+            commonService.send(player, MessageKey.USAGE_REGISTER);
+            return false;
+        }
+
+        if (secondArgType == CONFIRMATION) {
+            if (arguments.get(0).equals(arguments.get(1))) {
+                return true;
+            } else {
+                commonService.send(player, MessageKey.PASSWORD_MATCH_ERROR);
+                return false;
+            }
+        } else if (secondArgType == EMAIL_MANDATORY || secondArgType == EMAIL_OPTIONAL) {
+            if (validationService.validateEmail(arguments.get(1))) {
+                return true;
+            } else {
+                commonService.send(player, MessageKey.INVALID_EMAIL);
+                return false;
+            }
+        } else {
+            throw new IllegalStateException("Unknown secondary argument type '" + secondArgType + "'");
+        }
+    }
+
+    private void handleEmailRegistration(Player player, List<String> arguments) {
+        if (!emailService.hasAllInformation()) {
+            commonService.send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
+            logger.warning("Cannot register player '" + player.getName() + "': no email or password is set "
+                + "to send emails from. Please adjust your config at " + EmailSettings.MAIL_ACCOUNT.getPath());
+            return;
+        }
+
+        final String email = arguments.get(0);
+        if (!validationService.validateEmail(email)) {
+            commonService.send(player, MessageKey.INVALID_EMAIL);
+        } else if (isSecondArgValidForEmailRegistration(player, arguments)) {
+            management.performRegister(RegistrationMethod.EMAIL_REGISTRATION,
+                EmailRegisterParams.of(player, email));
+            Timer timer = new Timer();
+            timer.schedule(new TimerTask() {
+                @Override
+                public void run() {
+                    if (dataSource.getAuth(player.getName()) != null) {
+                        if (dataSource.getAuth(player.getName()).getLastLogin() == null) {
+                            management.performUnregisterByAdmin(null, player.getName(), player);
+                            timer.cancel();
+                        }
+                    } else {
+                        timer.cancel();
+                    }
+                }
+            }, 600000);
+        }
+    }
+
+    /**
+     * Verifies that the second argument is valid (based on the configuration)
+     * to perform an email registration. The player is informed if the check
+     * is unsuccessful.
+     *
+     * @param player the player to register
+     * @param arguments the provided arguments
+     * @return true if valid, false otherwise
+     */
+    private boolean isSecondArgValidForEmailRegistration(Player player, List<String> arguments) {
+        RegisterSecondaryArgument secondArgType = commonService.getProperty(REGISTER_SECOND_ARGUMENT);
+        // cases where args.size < 2
+        if (secondArgType == NONE || secondArgType == EMAIL_OPTIONAL && arguments.size() < 2) {
+            return true;
+        } else if (arguments.size() < 2) {
+            commonService.send(player, MessageKey.USAGE_REGISTER);
+            return false;
+        }
+
+        if (secondArgType == EMAIL_OPTIONAL || secondArgType == EMAIL_MANDATORY || secondArgType == CONFIRMATION) {
+            if (arguments.get(0).equals(arguments.get(1))) {
+                return true;
+            } else {
+                commonService.send(player, MessageKey.USAGE_REGISTER);
+                return false;
+            }
+        } else {
+            throw new IllegalStateException("Unknown secondary argument type '" + secondArgType + "'");
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/totp/AddTotpCommand.java

@@ -0,0 +1,43 @@
+package fr.xephi.authme.command.executable.totp;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.security.totp.GenerateTotpService;
+import fr.xephi.authme.security.totp.TotpAuthenticator.TotpGenerationResult;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command for a player to enable TOTP.
+ */
+public class AddTotpCommand extends PlayerCommand {
+
+    @Inject
+    private GenerateTotpService generateTotpService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private Messages messages;
+
+    @Override
+    protected void runCommand(Player player, List<String> arguments) {
+        PlayerAuth auth = playerCache.getAuth(player.getName());
+        if (auth == null) {
+            messages.send(player, MessageKey.NOT_LOGGED_IN);
+        } else if (auth.getTotpKey() == null) {
+            TotpGenerationResult createdTotpInfo = generateTotpService.generateTotpKey(player);
+            messages.send(player, MessageKey.TWO_FACTOR_CREATE,
+                createdTotpInfo.getTotpKey(), createdTotpInfo.getAuthenticatorQrCodeUrl());
+            messages.send(player, MessageKey.TWO_FACTOR_CREATE_CONFIRMATION_REQUIRED);
+        } else {
+            messages.send(player, MessageKey.TWO_FACTOR_ALREADY_ENABLED);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/totp/ConfirmTotpCommand.java

@@ -0,0 +1,74 @@
+package fr.xephi.authme.command.executable.totp;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.security.totp.GenerateTotpService;
+import fr.xephi.authme.security.totp.TotpAuthenticator.TotpGenerationResult;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command to enable TOTP by supplying the proper code as confirmation.
+ */
+public class ConfirmTotpCommand extends PlayerCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(ConfirmTotpCommand.class);
+
+    @Inject
+    private GenerateTotpService generateTotpService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private Messages messages;
+
+    @Override
+    protected void runCommand(Player player, List<String> arguments) {
+        PlayerAuth auth = playerCache.getAuth(player.getName());
+        if (auth == null) {
+            messages.send(player, MessageKey.NOT_LOGGED_IN);
+        } else if (auth.getTotpKey() != null) {
+            messages.send(player, MessageKey.TWO_FACTOR_ALREADY_ENABLED);
+        } else {
+            verifyTotpCodeConfirmation(player, auth, arguments.get(0));
+        }
+    }
+
+    private void verifyTotpCodeConfirmation(Player player, PlayerAuth auth, String inputTotpCode) {
+        final TotpGenerationResult totpDetails = generateTotpService.getGeneratedTotpKey(player);
+        if (totpDetails == null) {
+            messages.send(player, MessageKey.TWO_FACTOR_ENABLE_ERROR_NO_CODE);
+        } else {
+            boolean isCodeValid = generateTotpService.isTotpCodeCorrectForGeneratedTotpKey(player, inputTotpCode);
+            if (isCodeValid) {
+                generateTotpService.removeGenerateTotpKey(player);
+                insertTotpKeyIntoDatabase(player, auth, totpDetails);
+            } else {
+                messages.send(player, MessageKey.TWO_FACTOR_ENABLE_ERROR_WRONG_CODE);
+            }
+        }
+    }
+
+    private void insertTotpKeyIntoDatabase(Player player, PlayerAuth auth, TotpGenerationResult totpDetails) {
+        if (dataSource.setTotpKey(player.getName(), totpDetails.getTotpKey())) {
+            messages.send(player, MessageKey.TWO_FACTOR_ENABLE_SUCCESS);
+            auth.setTotpKey(totpDetails.getTotpKey());
+            playerCache.updatePlayer(auth);
+            logger.info("Player '" + player.getName() + "' has successfully added a TOTP key to their account");
+        } else {
+            messages.send(player, MessageKey.ERROR);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/totp/RemoveTotpCommand.java

@@ -0,0 +1,62 @@
+package fr.xephi.authme.command.executable.totp;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.security.totp.TotpAuthenticator;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command for a player to remove 2FA authentication.
+ */
+public class RemoveTotpCommand extends PlayerCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(RemoveTotpCommand.class);
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private TotpAuthenticator totpAuthenticator;
+
+    @Inject
+    private Messages messages;
+
+    @Override
+    protected void runCommand(Player player, List<String> arguments) {
+        PlayerAuth auth = playerCache.getAuth(player.getName());
+        if (auth == null) {
+            messages.send(player, MessageKey.NOT_LOGGED_IN);
+        } else if (auth.getTotpKey() == null) {
+            messages.send(player, MessageKey.TWO_FACTOR_NOT_ENABLED_ERROR);
+        } else {
+            if (totpAuthenticator.checkCode(auth, arguments.get(0))) {
+                removeTotpKeyFromDatabase(player, auth);
+            } else {
+                messages.send(player, MessageKey.TWO_FACTOR_INVALID_CODE);
+            }
+        }
+    }
+
+    private void removeTotpKeyFromDatabase(Player player, PlayerAuth auth) {
+        if (dataSource.removeTotpKey(auth.getNickname())) {
+            auth.setTotpKey(null);
+            playerCache.updatePlayer(auth);
+            messages.send(player, MessageKey.TWO_FACTOR_REMOVED_SUCCESS);
+            logger.info("Player '" + player.getName() + "' removed their TOTP key");
+        } else {
+            messages.send(player, MessageKey.ERROR);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/totp/TotpBaseCommand.java

@@ -0,0 +1,29 @@
+package fr.xephi.authme.command.executable.totp;
+
+import fr.xephi.authme.command.CommandMapper;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.command.FoundCommandResult;
+import fr.xephi.authme.command.help.HelpProvider;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Base command for /totp.
+ */
+public class TotpBaseCommand implements ExecutableCommand {
+
+    @Inject
+    private CommandMapper commandMapper;
+
+    @Inject
+    private HelpProvider helpProvider;
+
+    @Override
+    public void executeCommand(CommandSender sender, List<String> arguments) {
+        FoundCommandResult result = commandMapper.mapPartsToCommand(sender, Collections.singletonList("totp"));
+        helpProvider.outputHelp(sender, result, HelpProvider.SHOW_CHILDREN);
+    }
+}

src/main/java/fr/xephi/authme/command/executable/totp/TotpCodeCommand.java

@@ -0,0 +1,79 @@
+package fr.xephi.authme.command.executable.totp;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.data.limbo.LimboPlayer;
+import fr.xephi.authme.data.limbo.LimboPlayerState;
+import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.process.login.AsynchronousLogin;
+import fr.xephi.authme.security.totp.TotpAuthenticator;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * TOTP code command for processing the 2FA code during the login process.
+ */
+public class TotpCodeCommand extends PlayerCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(TotpCodeCommand.class);
+
+    @Inject
+    private LimboService limboService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private Messages messages;
+
+    @Inject
+    private TotpAuthenticator totpAuthenticator;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private AsynchronousLogin asynchronousLogin;
+
+    @Override
+    protected void runCommand(Player player, List<String> arguments) {
+        if (playerCache.isAuthenticated(player.getName())) {
+            messages.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
+            return;
+        }
+
+        PlayerAuth auth = dataSource.getAuth(player.getName());
+        if (auth == null) {
+            messages.send(player, MessageKey.REGISTER_MESSAGE);
+            return;
+        }
+
+        LimboPlayer limbo = limboService.getLimboPlayer(player.getName());
+        if (limbo != null && limbo.getState() == LimboPlayerState.TOTP_REQUIRED) {
+            processCode(player, auth, arguments.get(0));
+        } else {
+            logger.debug(() -> "Aborting TOTP check for player '" + player.getName()
+                + "'. Invalid limbo state: " + (limbo == null ? "no limbo" : limbo.getState()));
+            messages.send(player, MessageKey.LOGIN_MESSAGE);
+        }
+    }
+
+    private void processCode(Player player, PlayerAuth auth, String inputCode) {
+        boolean isCodeValid = totpAuthenticator.checkCode(auth, inputCode);
+        if (isCodeValid) {
+            logger.debug("Successfully checked TOTP code for `{0}`", player.getName());
+            asynchronousLogin.performLogin(player, auth);
+        } else {
+            logger.debug("Input TOTP code was invalid for player `{0}`", player.getName());
+            messages.send(player, MessageKey.TWO_FACTOR_INVALID_CODE);
+        }
+    }
+}

src/main/java/fr/xephi/authme/command/executable/unregister/UnregisterCommand.java

@@ -0,0 +1,62 @@
+package fr.xephi.authme.command.executable.unregister;
+
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.VerificationCodeManager;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Command for a player to unregister himself.
+ */
+public class UnregisterCommand extends PlayerCommand {
+
+    @Inject
+    private Management management;
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    @Inject
+    private VerificationCodeManager codeManager;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        String playerPass = arguments.get(0);
+        String playerName = player.getName();
+
+        // Make sure the player is authenticated
+        if (!playerCache.isAuthenticated(playerName)) {
+            commonService.send(player, MessageKey.NOT_LOGGED_IN);
+            return;
+        }
+
+        // Check if the user has been verified or not
+        if (codeManager.isVerificationRequired(player)) {
+            codeManager.codeExistOrGenerateNew(playerName);
+            commonService.send(player, MessageKey.VERIFICATION_CODE_REQUIRED);
+            return;
+        }
+
+        // Unregister the player
+        management.performUnregister(player, playerPass);
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_UNREGISTER;
+    }
+
+    @Override
+    protected String getAlternativeCommand() {
+        return "/authme unregister <player>";
+    }
+}

src/main/java/fr/xephi/authme/command/executable/verification/VerificationCommand.java

@@ -0,0 +1,61 @@
+package fr.xephi.authme.command.executable.verification;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.command.PlayerCommand;
+import fr.xephi.authme.data.VerificationCodeManager;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+import java.util.List;
+
+/**
+ * Used to complete the email verification process.
+ */
+public class VerificationCommand extends PlayerCommand {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(VerificationCommand.class);
+
+    @Inject
+    private CommonService commonService;
+
+    @Inject
+    private VerificationCodeManager codeManager;
+
+    @Override
+    public void runCommand(Player player, List<String> arguments) {
+        final String playerName = player.getName();
+
+        if (!codeManager.canSendMail()) {
+            logger.warning("Mail API is not set");
+            commonService.send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
+            return;
+        }
+
+        if (codeManager.isVerificationRequired(player)) {
+            if (codeManager.isCodeRequired(playerName)) {
+                if (codeManager.checkCode(playerName, arguments.get(0))) {
+                    commonService.send(player, MessageKey.VERIFICATION_CODE_VERIFIED);
+                } else {
+                    commonService.send(player, MessageKey.INCORRECT_VERIFICATION_CODE);
+                }
+            } else {
+                commonService.send(player, MessageKey.VERIFICATION_CODE_EXPIRED);
+            }
+        } else {
+            if (codeManager.hasEmail(playerName)) {
+                commonService.send(player, MessageKey.VERIFICATION_CODE_ALREADY_VERIFIED);
+            } else {
+                commonService.send(player, MessageKey.VERIFICATION_CODE_EMAIL_NEEDED);
+                commonService.send(player, MessageKey.ADD_EMAIL_MESSAGE);
+            }
+        }
+    }
+
+    @Override
+    public MessageKey getArgumentsMismatchMessage() {
+        return MessageKey.USAGE_VERIFICATION_CODE;
+    }
+}

src/main/java/fr/xephi/authme/command/help/HelpMessage.java

@@ -0,0 +1,43 @@
+package fr.xephi.authme.command.help;
+
+/**
+ * Common, non-generic keys for messages used when showing command help.
+ * All keys are prefixed with {@code common}.
+ */
+public enum HelpMessage {
+
+    HEADER("header"),
+
+    OPTIONAL("optional"),
+
+    HAS_PERMISSION("hasPermission"),
+
+    NO_PERMISSION("noPermission"),
+
+    DEFAULT("default"),
+
+    RESULT("result");
+
+    private static final String PREFIX = "common.";
+    private final String key;
+
+    /**
+     * Constructor.
+     *
+     * @param key the message key
+     */
+    HelpMessage(String key) {
+        this.key = PREFIX + key;
+    }
+
+    /** @return the message key */
+    public String getKey() {
+        return key;
+    }
+
+    /** @return the key without the common prefix */
+    public String getEntryKey() {
+        // Note ljacqu 20171008: #getKey is called more often than this method, so we optimize for the former method
+        return key.substring(PREFIX.length());
+    }
+}

src/main/java/fr/xephi/authme/command/help/HelpMessagesService.java

@@ -0,0 +1,117 @@
+package fr.xephi.authme.command.help;
+
+import com.google.common.base.CaseFormat;
+import fr.xephi.authme.command.CommandArgumentDescription;
+import fr.xephi.authme.command.CommandDescription;
+import fr.xephi.authme.command.CommandUtils;
+import fr.xephi.authme.message.HelpMessagesFileHandler;
+import fr.xephi.authme.permission.DefaultPermission;
+
+import javax.inject.Inject;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+/**
+ * Manages translatable help messages.
+ */
+public class HelpMessagesService {
+
+    private static final String COMMAND_PREFIX = "commands.";
+    private static final String DESCRIPTION_SUFFIX = ".description";
+    private static final String DETAILED_DESCRIPTION_SUFFIX = ".detailedDescription";
+    private static final String DEFAULT_PERMISSIONS_PATH = "common.defaultPermissions.";
+
+    private final HelpMessagesFileHandler helpMessagesFileHandler;
+
+    @Inject
+    HelpMessagesService(HelpMessagesFileHandler helpMessagesFileHandler) {
+        this.helpMessagesFileHandler = helpMessagesFileHandler;
+    }
+
+    /**
+     * Creates a copy of the supplied command description with localized messages where present.
+     *
+     * @param command the command to build a localized version of
+     * @return the localized description
+     */
+    public CommandDescription buildLocalizedDescription(CommandDescription command) {
+        final String path = COMMAND_PREFIX + getCommandSubPath(command);
+        if (!helpMessagesFileHandler.hasSection(path)) {
+            // Messages file does not have a section for this command - return the provided command
+            return command;
+        }
+
+        CommandDescription.CommandBuilder builder = CommandDescription.builder()
+            .description(getText(path + DESCRIPTION_SUFFIX, command::getDescription))
+            .detailedDescription(getText(path + DETAILED_DESCRIPTION_SUFFIX, command::getDetailedDescription))
+            .executableCommand(command.getExecutableCommand())
+            .parent(command.getParent())
+            .labels(command.getLabels())
+            .permission(command.getPermission());
+
+        int i = 1;
+        for (CommandArgumentDescription argument : command.getArguments()) {
+            String argPath = path + ".arg" + i;
+            String label = getText(argPath + ".label", argument::getName);
+            String description = getText(argPath + ".description", argument::getDescription);
+            builder.withArgument(label, description, argument.isOptional());
+            ++i;
+        }
+
+        CommandDescription localCommand = builder.build();
+        localCommand.getChildren().addAll(command.getChildren());
+        return localCommand;
+    }
+
+    public String getDescription(CommandDescription command) {
+        return getText(COMMAND_PREFIX + getCommandSubPath(command) + DESCRIPTION_SUFFIX, command::getDescription);
+    }
+
+    public String getMessage(HelpMessage message) {
+        return helpMessagesFileHandler.getMessage(message.getKey());
+    }
+
+    public String getMessage(HelpSection section) {
+        return helpMessagesFileHandler.getMessage(section.getKey());
+    }
+
+    public String getMessage(DefaultPermission defaultPermission) {
+        // e.g. {default_permissions_path}.opOnly for DefaultPermission.OP_ONLY
+        String path = DEFAULT_PERMISSIONS_PATH + getDefaultPermissionsSubPath(defaultPermission);
+        return helpMessagesFileHandler.getMessage(path);
+    }
+
+    public static String getDefaultPermissionsSubPath(DefaultPermission defaultPermission) {
+        return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, defaultPermission.name());
+    }
+
+    private String getText(String path, Supplier<String> defaultTextGetter) {
+        String message = helpMessagesFileHandler.getMessageIfExists(path);
+        return message == null
+            ? defaultTextGetter.get()
+            : message;
+    }
+
+
+    /**
+     * Triggers a reload of the help messages file. Note that this method is not needed
+     * to be called for /authme reload.
+     */
+    public void reloadMessagesFile() {
+        helpMessagesFileHandler.reload();
+    }
+
+    /**
+     * Returns the command subpath for the given command (i.e. the path to the translations for the given
+     * command under "commands").
+     *
+     * @param command the command to process
+     * @return the subpath for the command's texts
+     */
+    public static String getCommandSubPath(CommandDescription command) {
+        return CommandUtils.constructParentList(command)
+            .stream()
+            .map(cmd -> cmd.getLabels().get(0))
+            .collect(Collectors.joining("."));
+    }
+}

src/main/java/fr/xephi/authme/command/help/HelpProvider.java

@@ -0,0 +1,328 @@
+package fr.xephi.authme.command.help;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import fr.xephi.authme.command.CommandArgumentDescription;
+import fr.xephi.authme.command.CommandDescription;
+import fr.xephi.authme.command.CommandUtils;
+import fr.xephi.authme.command.FoundCommandResult;
+import fr.xephi.authme.initialization.Reloadable;
+import fr.xephi.authme.permission.DefaultPermission;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsManager;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+import static fr.xephi.authme.command.help.HelpSection.DETAILED_DESCRIPTION;
+import static fr.xephi.authme.command.help.HelpSection.SHORT_DESCRIPTION;
+import static java.util.Collections.singletonList;
+
+/**
+ * Help syntax generator for AuthMe commands.
+ */
+public class HelpProvider implements Reloadable {
+
+    // --- Bit flags ---
+    /** Set to show a command overview. */
+    public static final int SHOW_COMMAND          = 0x001;
+    /** Set to show the description of the command. */
+    public static final int SHOW_DESCRIPTION      = 0x002;
+    /** Set to show the detailed description of the command. */
+    public static final int SHOW_LONG_DESCRIPTION = 0x004;
+    /** Set to include the arguments the command takes. */
+    public static final int SHOW_ARGUMENTS        = 0x008;
+    /** Set to show the permissions required to execute the command. */
+    public static final int SHOW_PERMISSIONS      = 0x010;
+    /** Set to show alternative labels for the command. */
+    public static final int SHOW_ALTERNATIVES     = 0x020;
+    /** Set to show the child commands of the command. */
+    public static final int SHOW_CHILDREN         = 0x040;
+
+    /** Shortcut for setting all options. */
+    public static final int ALL_OPTIONS = ~0;
+
+    private final PermissionsManager permissionsManager;
+    private final HelpMessagesService helpMessagesService;
+    /** int with bit flags set corresponding to the above constants for enabled sections. */
+    private Integer enabledSections;
+
+    @Inject
+    HelpProvider(PermissionsManager permissionsManager, HelpMessagesService helpMessagesService) {
+        this.permissionsManager = permissionsManager;
+        this.helpMessagesService = helpMessagesService;
+    }
+
+    /**
+     * Builds the help messages based on the provided arguments.
+     *
+     * @param sender the sender to evaluate permissions with
+     * @param result the command result to create help for
+     * @param options output options
+     * @return the generated help messages
+     */
+    private List<String> buildHelpOutput(CommandSender sender, FoundCommandResult result, int options) {
+        if (result.getCommandDescription() == null) {
+            return singletonList(ChatColor.DARK_RED + "Failed to retrieve any help information!");
+        }
+
+        List<String> lines = new ArrayList<>();
+        options = filterDisabledSections(options);
+        if (options == 0) {
+            // Return directly if no options are enabled so we don't include the help header
+            return lines;
+        }
+        String header = helpMessagesService.getMessage(HelpMessage.HEADER);
+        if (!header.isEmpty()) {
+            lines.add(ChatColor.GOLD + header);
+        }
+
+        CommandDescription command = helpMessagesService.buildLocalizedDescription(result.getCommandDescription());
+        List<String> correctLabels = ImmutableList.copyOf(filterCorrectLabels(command, result.getLabels()));
+
+        if (hasFlag(SHOW_COMMAND, options)) {
+            lines.add(ChatColor.GOLD + helpMessagesService.getMessage(HelpSection.COMMAND) + ": "
+                + CommandUtils.buildSyntax(command, correctLabels));
+        }
+        if (hasFlag(SHOW_DESCRIPTION, options)) {
+            lines.add(ChatColor.GOLD + helpMessagesService.getMessage(SHORT_DESCRIPTION) + ": "
+                + ChatColor.WHITE + command.getDescription());
+        }
+        if (hasFlag(SHOW_LONG_DESCRIPTION, options)) {
+            lines.add(ChatColor.GOLD + helpMessagesService.getMessage(DETAILED_DESCRIPTION) + ":");
+            lines.add(ChatColor.WHITE + " " + command.getDetailedDescription());
+        }
+        if (hasFlag(SHOW_ARGUMENTS, options)) {
+            addArgumentsInfo(command, lines);
+        }
+        if (hasFlag(SHOW_PERMISSIONS, options) && sender != null) {
+            addPermissionsInfo(command, sender, lines);
+        }
+        if (hasFlag(SHOW_ALTERNATIVES, options)) {
+            addAlternativesInfo(command, correctLabels, lines);
+        }
+        if (hasFlag(SHOW_CHILDREN, options)) {
+            addChildrenInfo(command, correctLabels, lines);
+        }
+
+        return lines;
+    }
+
+    /**
+     * Outputs the help for a given command.
+     *
+     * @param sender the sender to output the help to
+     * @param result the result to output information about
+     * @param options output options
+     */
+    public void outputHelp(CommandSender sender, FoundCommandResult result, int options) {
+        List<String> lines = buildHelpOutput(sender, result, options);
+        for (String line : lines) {
+            sender.sendMessage(line);
+        }
+    }
+
+    @Override
+    public void reload() {
+        // We don't know about the reloading order of the classes, i.e. we cannot assume that HelpMessagesService
+        // has already been reloaded. So set the enabledSections flag to null and redefine it first time needed.
+        enabledSections = null;
+    }
+
+    /**
+     * Removes any disabled sections from the options. Sections are considered disabled
+     * if the translated text for the section is empty.
+     *
+     * @param options the options to process
+     * @return the options without any disabled sections
+     */
+    @SuppressWarnings("checkstyle:BooleanExpressionComplexity")
+    private int filterDisabledSections(int options) {
+        if (enabledSections == null) {
+            enabledSections = flagFor(HelpSection.COMMAND, SHOW_COMMAND)
+                | flagFor(HelpSection.SHORT_DESCRIPTION, SHOW_DESCRIPTION)
+                | flagFor(HelpSection.DETAILED_DESCRIPTION, SHOW_LONG_DESCRIPTION)
+                | flagFor(HelpSection.ARGUMENTS, SHOW_ARGUMENTS)
+                | flagFor(HelpSection.PERMISSIONS, SHOW_PERMISSIONS)
+                | flagFor(HelpSection.ALTERNATIVES, SHOW_ALTERNATIVES)
+                | flagFor(HelpSection.CHILDREN, SHOW_CHILDREN);
+        }
+        return options & enabledSections;
+    }
+
+    private int flagFor(HelpSection section, int flag) {
+        return helpMessagesService.getMessage(section).isEmpty() ? 0 : flag;
+    }
+
+    /**
+     * Adds help info about the given command's arguments into the provided list.
+     *
+     * @param command the command to generate arguments info for
+     * @param lines the output collection to add the info to
+     */
+    private void addArgumentsInfo(CommandDescription command, List<String> lines) {
+        if (command.getArguments().isEmpty()) {
+            return;
+        }
+
+        lines.add(ChatColor.GOLD + helpMessagesService.getMessage(HelpSection.ARGUMENTS) + ":");
+        StringBuilder argString = new StringBuilder();
+        String optionalText = " (" + helpMessagesService.getMessage(HelpMessage.OPTIONAL) + ")";
+        for (CommandArgumentDescription argument : command.getArguments()) {
+            argString.setLength(0);
+            argString.append(" ").append(ChatColor.YELLOW).append(ChatColor.ITALIC).append(argument.getName())
+                .append(": ").append(ChatColor.WHITE).append(argument.getDescription());
+
+            if (argument.isOptional()) {
+                argString.append(ChatColor.GRAY).append(ChatColor.ITALIC).append(optionalText);
+            }
+            lines.add(argString.toString());
+        }
+    }
+
+    /**
+     * Adds help info about the given command's alternative labels into the provided list.
+     *
+     * @param command the command for which to generate info about its labels
+     * @param correctLabels labels used to access the command (sanitized)
+     * @param lines the output collection to add the info to
+     */
+    private void addAlternativesInfo(CommandDescription command, List<String> correctLabels, List<String> lines) {
+        if (command.getLabels().size() <= 1) {
+            return;
+        }
+
+        lines.add(ChatColor.GOLD + helpMessagesService.getMessage(HelpSection.ALTERNATIVES) + ":");
+
+        // Label with which the command was called -> don't show it as an alternative
+        final String usedLabel;
+        // Takes alternative label and constructs list of labels, e.g. "reg" -> [authme, reg]
+        final Function<String, List<String>> commandLabelsFn;
+
+        if (correctLabels.size() == 1) {
+            usedLabel = correctLabels.get(0);
+            commandLabelsFn = label -> singletonList(label);
+        } else {
+            usedLabel = correctLabels.get(1);
+            commandLabelsFn = label -> Arrays.asList(correctLabels.get(0), label);
+        }
+
+        // Create a list of alternatives
+        for (String label : command.getLabels()) {
+            if (!label.equalsIgnoreCase(usedLabel)) {
+                lines.add(" " + CommandUtils.buildSyntax(command, commandLabelsFn.apply(label)));
+            }
+        }
+    }
+
+    /**
+     * Adds help info about the given command's permissions into the provided list.
+     *
+     * @param command the command to generate permissions info for
+     * @param sender the command sender, used to evaluate permissions
+     * @param lines the output collection to add the info to
+     */
+    private void addPermissionsInfo(CommandDescription command, CommandSender sender, List<String> lines) {
+        PermissionNode permission = command.getPermission();
+        if (permission == null) {
+            return;
+        }
+        lines.add(ChatColor.GOLD + helpMessagesService.getMessage(HelpSection.PERMISSIONS) + ":");
+
+        boolean hasPermission = permissionsManager.hasPermission(sender, permission);
+        lines.add(String.format(" " + ChatColor.YELLOW + ChatColor.ITALIC + "%s" + ChatColor.GRAY + " (%s)",
+            permission.getNode(), getLocalPermissionText(hasPermission)));
+
+        // Addendum to the line to specify whether the sender has permission or not when default is OP_ONLY
+        final DefaultPermission defaultPermission = permission.getDefaultPermission();
+        String addendum = "";
+        if (DefaultPermission.OP_ONLY.equals(defaultPermission)) {
+            addendum = " (" + getLocalPermissionText(defaultPermission.evaluate(sender)) + ")";
+        }
+        lines.add(ChatColor.GOLD + helpMessagesService.getMessage(HelpMessage.DEFAULT) + ": "
+            + ChatColor.GRAY + ChatColor.ITALIC + helpMessagesService.getMessage(defaultPermission) + addendum);
+
+        // Evaluate if the sender has permission to the command
+        ChatColor permissionColor;
+        String permissionText;
+        if (permissionsManager.hasPermission(sender, command.getPermission())) {
+            permissionColor = ChatColor.GREEN;
+            permissionText = getLocalPermissionText(true);
+        } else {
+            permissionColor = ChatColor.DARK_RED;
+            permissionText = getLocalPermissionText(false);
+        }
+        lines.add(String.format(ChatColor.GOLD + " %s: %s" + ChatColor.ITALIC + "%s",
+            helpMessagesService.getMessage(HelpMessage.RESULT), permissionColor, permissionText));
+    }
+
+    private String getLocalPermissionText(boolean hasPermission) {
+        if (hasPermission) {
+            return helpMessagesService.getMessage(HelpMessage.HAS_PERMISSION);
+        }
+        return helpMessagesService.getMessage(HelpMessage.NO_PERMISSION);
+    }
+
+    /**
+     * Adds help info about the given command's child command into the provided list.
+     *
+     * @param command the command for which to generate info about its child commands
+     * @param correctLabels the labels used to access the given command (sanitized)
+     * @param lines the output collection to add the info to
+     */
+    private void addChildrenInfo(CommandDescription command, List<String> correctLabels, List<String> lines) {
+        if (command.getChildren().isEmpty()) {
+            return;
+        }
+
+        lines.add(ChatColor.GOLD + helpMessagesService.getMessage(HelpSection.CHILDREN) + ":");
+        String parentCommandPath = String.join(" ", correctLabels);
+        for (CommandDescription child : command.getChildren()) {
+            lines.add(" /" + parentCommandPath + " " + child.getLabels().get(0)
+                + ChatColor.GRAY + ChatColor.ITALIC + ": " + helpMessagesService.getDescription(child));
+        }
+    }
+
+    private static boolean hasFlag(int flag, int options) {
+        return (flag & options) != 0;
+    }
+
+    /**
+     * Returns a list of labels for the given command, using the labels from the provided labels list
+     * as long as they are correct.
+     * <p>
+     * Background: commands may have multiple labels (e.g. /authme register vs. /authme reg). It is interesting
+     * for us to keep with which label the user requested the command. At the same time, when a user inputs a
+     * non-existent label, we try to find the most similar one. This method keeps all labels that exists and will
+     * default to the command's first label when an invalid label is encountered.
+     * <p>
+     * Examples:
+     *   command = "authme register", labels = {authme, egister}. Output: {authme, register}
+     *   command = "authme register", labels = {authme, reg}.     Output: {authme, reg}
+     *
+     * @param command the command to compare the labels against
+     * @param labels the labels as input by the user
+     * @return list of correct labels, keeping the user's input where possible
+     */
+    @VisibleForTesting
+    static List<String> filterCorrectLabels(CommandDescription command, List<String> labels) {
+        List<CommandDescription> commands = CommandUtils.constructParentList(command);
+        List<String> correctLabels = new ArrayList<>();
+        boolean foundIncorrectLabel = false;
+        for (int i = 0; i < commands.size(); ++i) {
+            if (!foundIncorrectLabel && i < labels.size() && commands.get(i).hasLabel(labels.get(i))) {
+                correctLabels.add(labels.get(i));
+            } else {
+                foundIncorrectLabel = true;
+                correctLabels.add(commands.get(i).getLabels().get(0));
+            }
+        }
+        return correctLabels;
+    }
+
+}

src/main/java/fr/xephi/authme/command/help/HelpSection.java

@@ -0,0 +1,44 @@
+package fr.xephi.authme.command.help;
+
+/**
+ * Translatable sections. Message keys are prefixed by {@code section}.
+ */
+public enum HelpSection {
+
+    COMMAND("command"),
+
+    SHORT_DESCRIPTION("description"),
+
+    DETAILED_DESCRIPTION("detailedDescription"),
+
+    ARGUMENTS("arguments"),
+
+    ALTERNATIVES("alternatives"),
+
+    PERMISSIONS("permissions"),
+
+    CHILDREN("children");
+
+    private static final String PREFIX = "section.";
+    private final String key;
+
+    /**
+     * Constructor.
+     *
+     * @param key the message key
+     */
+    HelpSection(String key) {
+        this.key = PREFIX + key;
+    }
+
+    /** @return the message key */
+    public String getKey() {
+        return key;
+    }
+
+    /** @return the key without the common prefix */
+    public String getEntryKey() {
+        // Note ljacqu 20171008: #getKey is called more often than this method, so we optimize for the former method
+        return key.substring(PREFIX.length());
+    }
+}