#1113 Handle LimboPlayer tasks via LimboService

- Add methods to LimboService for handling messages to make it the only relevant Limbo class for outside classes
  - Move LimboPlayerTaskManager to limbo package and make it package-private
- Create MessageTask and TimeoutTask immediately when LimboPlayer is created
- #1112 MessageTask: improve efficiency by keeping reference to Player

src/main/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManager.java

@@ -0,0 +1,97 @@
+package fr.xephi.authme.data.limbo;
+
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.service.BukkitService;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
+import fr.xephi.authme.task.MessageTask;
+import fr.xephi.authme.task.TimeoutTask;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitTask;
+
+import javax.inject.Inject;
+
+import static fr.xephi.authme.service.BukkitService.TICKS_PER_SECOND;
+
+/**
+ * Registers tasks associated with a LimboPlayer.
+ */
+class LimboPlayerTaskManager {
+
+    @Inject
+    private Messages messages;
+
+    @Inject
+    private Settings settings;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    LimboPlayerTaskManager() {
+    }
+
+    /**
+     * Registers a {@link MessageTask} for the given player name.
+     *
+     * @param player the player
+     * @param limbo the associated limbo player of the player
+     * @param isRegistered whether the player is registered or not
+     *                     (false shows "please register", true shows "please log in")
+     */
+    void registerMessageTask(Player player, LimboPlayer limbo, boolean isRegistered) {
+        int interval = settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
+        MessageKey key = getMessageKey(isRegistered);
+        if (interval > 0) {
+            MessageTask messageTask = new MessageTask(player, messages.retrieve(key));
+            bukkitService.runTaskTimer(messageTask, 2 * TICKS_PER_SECOND, interval * TICKS_PER_SECOND);
+            limbo.setMessageTask(messageTask);
+        }
+    }
+
+    /**
+     * Registers a {@link TimeoutTask} for the given player according to the configuration.
+     *
+     * @param player the player to register a timeout task for
+     * @param limbo the associated limbo player
+     */
+    void registerTimeoutTask(Player player, LimboPlayer limbo) {
+        final int timeout = settings.getProperty(RestrictionSettings.TIMEOUT) * TICKS_PER_SECOND;
+        if (timeout > 0) {
+            String message = messages.retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR);
+            BukkitTask task = bukkitService.runTaskLater(new TimeoutTask(player, message, playerCache), timeout);
+            limbo.setTimeoutTask(task);
+        }
+    }
+
+    /**
+     * Null-safe method to set the muted flag on a message task.
+     *
+     * @param task the task to modify (or null)
+     * @param isMuted the value to set if task is not null
+     */
+    static void setMuted(MessageTask task, boolean isMuted) {
+        if (task != null) {
+            task.setMuted(isMuted);
+        }
+    }
+
+    /**
+     * Returns the appropriate message key according to the registration status and settings.
+     *
+     * @param isRegistered whether or not the username is registered
+     * @return the message key to display to the user
+     */
+    private static MessageKey getMessageKey(boolean isRegistered) {
+        if (isRegistered) {
+            return MessageKey.LOGIN_MESSAGE;
+        } else {
+            return MessageKey.REGISTER_MESSAGE;
+        }
+    }
+}

src/main/java/fr/xephi/authme/data/limbo/LimboService.java

@@ -10,6 +10,7 @@ import org.bukkit.entity.Player;
 
 import javax.inject.Inject;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
@@ -18,7 +19,7 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 public class LimboService {
 
-    private Map<String, LimboPlayer> entries = new ConcurrentHashMap<>();
+    private final Map<String, LimboPlayer> entries = new ConcurrentHashMap<>();
 
     @Inject
     private SpawnLoader spawnLoader;
@@ -29,6 +30,9 @@ public class LimboService {
     @Inject
     private Settings settings;
 
+    @Inject
+    private LimboPlayerTaskManager taskManager;
+
     LimboService() {
     }
 
@@ -62,6 +66,7 @@ public class LimboService {
             player.setWalkSpeed(walkSpeed);
             player.setFlySpeed(flySpeed);
             limbo.clearTasks();
+            ConsoleLogger.debug("Restored LimboPlayer stats for `{0}`", lowerName);
         }
     }
 
@@ -89,8 +94,9 @@ public class LimboService {
      * Creates a LimboPlayer for the given player and revokes all "limbo data" from the player.
      *
      * @param player the player to process
+     * @param isRegistered whether or not the player is registered
      */
-    public void createLimboPlayer(Player player) {
+    public void createLimboPlayer(Player player, boolean isRegistered) {
         final String name = player.getName().toLowerCase();
 
         LimboPlayer existingLimbo = entries.remove(name);
@@ -100,10 +106,53 @@ public class LimboService {
         }
 
         LimboPlayer limboPlayer = newLimboPlayer(player);
+        taskManager.registerMessageTask(player, limboPlayer, isRegistered);
+        taskManager.registerTimeoutTask(player, limboPlayer);
         revokeLimboStates(player);
         entries.put(name, limboPlayer);
     }
 
+    /**
+     * Creates new tasks for the given player and cancels the old ones for a newly registered player.
+     * This resets his time to log in (TimeoutTask) and updates the messages he is shown (MessageTask).
+     *
+     * @param player the player to reset the tasks for
+     */
+    public void replaceTasksAfterRegistration(Player player) {
+        getLimboOrLogError(player, "reset tasks")
+            .ifPresent(limbo -> {
+                taskManager.registerTimeoutTask(player, limbo);
+                taskManager.registerMessageTask(player, limbo, true);
+            });
+    }
+
+    /**
+     * Resets the message task associated with the player's LimboPlayer.
+     *
+     * @param player the player to set a new message task for
+     * @param isRegistered whether or not the player is registered
+     */
+    public void resetMessageTask(Player player, boolean isRegistered) {
+        getLimboOrLogError(player, "reset message task")
+            .ifPresent(limbo -> taskManager.registerMessageTask(player, limbo, isRegistered));
+    }
+
+    /**
+     * @param player the player whose message task should be muted
+     */
+    public void muteMessageTask(Player player) {
+        getLimboOrLogError(player, "mute message task")
+            .ifPresent(limbo -> LimboPlayerTaskManager.setMuted(limbo.getMessageTask(), true));
+    }
+
+    /**
+     * @param player the player whose message task should be unmuted
+     */
+    public void unmuteMessageTask(Player player) {
+        getLimboOrLogError(player, "unmute message task")
+            .ifPresent(limbo -> LimboPlayerTaskManager.setMuted(limbo.getMessageTask(), false));
+    }
+
     /**
      * Creates a LimboPlayer with the given player's details.
      *
@@ -143,4 +192,19 @@ public class LimboService {
             player.setWalkSpeed(0.0f);
         }
     }
+
+    /**
+     * Returns the limbo player for the given player or logs an error.
+     *
+     * @param player the player to retrieve the limbo player for
+     * @param context the action for which the limbo player is being retrieved (for logging)
+     * @return Optional with the limbo player
+     */
+    private Optional<LimboPlayer> getLimboOrLogError(Player player, String context) {
+        LimboPlayer limbo = entries.get(player.getName().toLowerCase());
+        if (limbo == null) {
+            ConsoleLogger.debug("No LimboPlayer found for `{0}`. Action: {1}", player.getName(), context);
+        }
+        return Optional.ofNullable(limbo);
+    }
 }