Massive code refactor, update dependencies, etc.

Лень фулл писать.
Closes #26

26 files changed, 937 insertions, 1361 deletions

diff --git a/src/main/java/net/elytrium/limboauth/LimboAuth.java b/src/main/java/net/elytrium/limboauth/LimboAuth.java
index afce924..55fee88 100644
--- a/src/main/java/net/elytrium/limboauth/LimboAuth.java
+++ b/src/main/java/net/elytrium/limboauth/LimboAuth.java
@@ -20,15 +20,15 @@ package net.elytrium.limboauth;
 import com.google.inject.Inject;
 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.dao.GenericRawResults;
+import com.j256.ormlite.db.DatabaseType;
 import com.j256.ormlite.field.FieldType;
 import com.j256.ormlite.jdbc.JdbcPooledConnectionSource;
 import com.j256.ormlite.stmt.QueryBuilder;
+import com.j256.ormlite.table.TableInfo;
 import com.j256.ormlite.table.TableUtils;
-import com.mojang.brigadier.tree.CommandNode;
 import com.velocitypowered.api.command.CommandManager;
-import com.velocitypowered.api.command.CommandMeta;
-import com.velocitypowered.api.command.CommandSource;
-import com.velocitypowered.api.command.SimpleCommand;
+import com.velocitypowered.api.event.EventManager;
 import com.velocitypowered.api.event.Subscribe;
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.plugin.Dependency;
@@ -37,6 +37,7 @@ import com.velocitypowered.api.plugin.PluginContainer;
 import com.velocitypowered.api.plugin.annotation.DataDirectory;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.io.File;
 import java.io.IOException;
 import java.net.InetAddress;
@@ -50,8 +51,6 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -66,10 +65,15 @@ import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import net.elytrium.java.commons.mc.serialization.Serializer;
+import net.elytrium.java.commons.mc.serialization.Serializers;
+import net.elytrium.java.commons.updates.UpdatesChecker;
 import net.elytrium.limboapi.api.Limbo;
 import net.elytrium.limboapi.api.LimboFactory;
 import net.elytrium.limboapi.api.chunk.Dimension;
 import net.elytrium.limboapi.api.chunk.VirtualWorld;
+import net.elytrium.limboapi.api.command.LimboCommandMeta;
 import net.elytrium.limboapi.api.file.SchematicFile;
 import net.elytrium.limboapi.api.file.StructureFile;
 import net.elytrium.limboapi.api.file.WorldFile;
@@ -90,12 +94,13 @@ import net.elytrium.limboauth.floodgate.FloodgateApiHolder;
 import net.elytrium.limboauth.handler.AuthSessionHandler;
 import net.elytrium.limboauth.listener.AuthListener;
 import net.elytrium.limboauth.model.RegisteredPlayer;
-import net.elytrium.limboauth.utils.UpdatesChecker;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.ComponentSerializer;
 import net.kyori.adventure.title.Title;
 import org.bstats.charts.SimplePie;
 import org.bstats.charts.SingleLineChart;
 import org.bstats.velocity.Metrics;
+import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.slf4j.Logger;
 
@@ -115,32 +120,52 @@ import org.slf4j.Logger;
 )
 public class LimboAuth {
 
+  @MonotonicNonNull
+  private static Logger LOGGER;
+  @MonotonicNonNull
+  private static Serializer SERIALIZER;
+
   private final Map<String, CachedSessionUser> cachedAuthChecks = new ConcurrentHashMap<>();
   private final Map<String, CachedPremiumUser> premiumCache = new ConcurrentHashMap<>();
   private final Map<UUID, Runnable> postLoginTasks = new ConcurrentHashMap<>();
   private final Set<String> unsafePasswords = new HashSet<>();
 
   private final HttpClient client = HttpClient.newHttpClient();
+
   private final ProxyServer server;
-  private final Logger logger;
   private final Metrics.Factory metricsFactory;
   private final Path dataDirectory;
+  private final File dataDirectoryFile;
+  private final File configFile;
   private final LimboFactory factory;
   private final FloodgateApiHolder floodgateApi;
 
-  private JdbcPooledConnectionSource connectionSource;
+  @Nullable
+  private Component loginPremium;
+  @Nullable
+  private Title loginPremiumTitle;
+  @Nullable
+  private Component loginFloodgate;
+  @Nullable
+  private Title loginFloodgateTitle;
+  private Component nicknameInvalidKick;
 
+  private JdbcPooledConnectionSource connectionSource;
   private Dao<RegisteredPlayer, String> playerDao;
   private Pattern nicknameValidationPattern;
   private Limbo authServer;
 
   @Inject
-  public LimboAuth(ProxyServer server, Logger logger, Metrics.Factory metricsFactory, @DataDirectory Path dataDirectory) {
+  public LimboAuth(Logger logger, ProxyServer server, Metrics.Factory metricsFactory, @DataDirectory Path dataDirectory) {
+    setLogger(logger);
+
     this.server = server;
-    this.logger = logger;
     this.metricsFactory = metricsFactory;
     this.dataDirectory = dataDirectory;
 
+    this.dataDirectoryFile = dataDirectory.toFile();
+    this.configFile = new File(this.dataDirectoryFile, "config.yml");
+
     this.factory = (LimboFactory) this.server.getPluginManager().getPlugin("limboapi").flatMap(PluginContainer::getInstance).orElseThrow();
 
     if (this.server.getPluginManager().getPlugin("floodgate").isPresent()) {
@@ -152,11 +177,11 @@ public class LimboAuth {
 
   @Subscribe
   public void onProxyInitialization(ProxyInitializeEvent event) throws Exception {
-    Metrics metrics = this.metricsFactory.make(this, 13700);
     System.setProperty("com.j256.simplelogging.level", "ERROR");
 
     this.reload();
 
+    Metrics metrics = this.metricsFactory.make(this, 13700);
     metrics.addCustomChart(new SimplePie("floodgate_auth", () -> String.valueOf(Settings.IMP.MAIN.FLOODGATE_NEED_AUTH)));
     metrics.addCustomChart(new SimplePie("premium_auth", () -> String.valueOf(Settings.IMP.MAIN.ONLINE_MODE_NEED_AUTH)));
     metrics.addCustomChart(new SimplePie("db_type", () -> Settings.IMP.DATABASE.STORAGE_TYPE));
@@ -166,54 +191,92 @@ public class LimboAuth {
     metrics.addCustomChart(new SimplePie("save_uuid", () -> String.valueOf(Settings.IMP.MAIN.SAVE_UUID)));
     metrics.addCustomChart(new SingleLineChart("registered_players", () -> Math.toIntExact(this.playerDao.countOf())));
 
-    UpdatesChecker.checkForUpdates(this.getLogger());
+    if (!UpdatesChecker.checkVersionByURL("https://raw.githubusercontent.com/Elytrium/LimboAuth/master/VERSION", Settings.IMP.VERSION)) {
+      LOGGER.error("****************************************");
+      LOGGER.warn("The new LimboAuth update was found, please update.");
+      LOGGER.error("https://github.com/Elytrium/LimboAuth/releases/");
+      LOGGER.error("****************************************");
+    }
   }
 
+  @SuppressFBWarnings(value = "NP_NULL_ON_SOME_PATH", justification = "LEGACY_AMPERSAND can't be null in velocity.")
   public void reload() throws Exception {
-    Settings.IMP.reload(new File(this.dataDirectory.toFile().getAbsoluteFile(), "config.yml"));
+    Settings.IMP.reload(this.configFile, Settings.IMP.PREFIX);
 
     if (this.floodgateApi == null && !Settings.IMP.MAIN.FLOODGATE_NEED_AUTH) {
-      throw new IllegalStateException("If you don't need to auth floodgate players please install floodgate plugin.");
+      throw new IllegalStateException("If you want floodgate players to automatically pass auth (floodgate-need-auth: false),"
+          + " please install floodgate plugin.");
+    }
+
+    ComponentSerializer<Component, Component, String> serializer = Serializers.valueOf(Settings.IMP.SERIALIZER.toUpperCase(Locale.ROOT)).getSerializer();
+    if (serializer == null) {
+      LOGGER.warn("The specified serializer could not be founded, using default. (LEGACY_AMPERSAND)");
+      setSerializer(new Serializer(Objects.requireNonNull(Serializers.LEGACY_AMPERSAND.getSerializer())));
+    } else {
+      setSerializer(new Serializer(serializer));
     }
 
+    TaskEvent.reload();
+    AuthSessionHandler.reload();
+
+    this.loginPremium = Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM.isEmpty() ? null : SERIALIZER.deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM);
+    if (Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_TITLE.isEmpty() && Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_SUBTITLE.isEmpty()) {
+      this.loginPremiumTitle = null;
+    } else {
+      this.loginPremiumTitle = Title.title(
+          SERIALIZER.deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_TITLE),
+          SERIALIZER.deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_SUBTITLE),
+          Settings.IMP.MAIN.PREMIUM_TITLE_SETTINGS.toTimes()
+      );
+    }
+
+    this.loginFloodgate = Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE.isEmpty() ? null : SERIALIZER.deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE);
+    if (Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_TITLE.isEmpty() && Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_SUBTITLE.isEmpty()) {
+      this.loginFloodgateTitle = null;
+    } else {
+      this.loginFloodgateTitle = Title.title(
+          SERIALIZER.deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_TITLE),
+          SERIALIZER.deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_SUBTITLE),
+          Settings.IMP.MAIN.PREMIUM_TITLE_SETTINGS.toTimes()
+      );
+    }
+
+    this.nicknameInvalidKick = SERIALIZER.deserialize(Settings.IMP.MAIN.STRINGS.NICKNAME_INVALID_KICK);
+
     if (Settings.IMP.MAIN.CHECK_PASSWORD_STRENGTH) {
       this.unsafePasswords.clear();
-      Path unsafePasswordsPath = Paths.get(this.dataDirectory.toFile().getAbsolutePath(), Settings.IMP.MAIN.UNSAFE_PASSWORDS_FILE);
+      Path unsafePasswordsPath = Paths.get(this.dataDirectoryFile.getAbsolutePath(), Settings.IMP.MAIN.UNSAFE_PASSWORDS_FILE);
       if (!unsafePasswordsPath.toFile().exists()) {
         Files.copy(Objects.requireNonNull(this.getClass().getResourceAsStream("/unsafe_passwords.txt")), unsafePasswordsPath);
       }
 
-      this.unsafePasswords.addAll(Files.lines(unsafePasswordsPath).collect(Collectors.toSet()));
+      try (Stream<String> unsafePasswordsStream = Files.lines(unsafePasswordsPath)) {
+        this.unsafePasswords.addAll(unsafePasswordsStream.collect(Collectors.toList()));
+      }
     }
 
     this.cachedAuthChecks.clear();
 
     Settings.DATABASE dbConfig = Settings.IMP.DATABASE;
-    // requireNonNull prevents the shade plugin from excluding the drivers in minimized jar.
     switch (dbConfig.STORAGE_TYPE.toLowerCase(Locale.ROOT)) {
       case "h2": {
-        Objects.requireNonNull(org.h2.Driver.class);
-        Objects.requireNonNull(org.h2.engine.Engine.class);
-        this.connectionSource = new JdbcPooledConnectionSource("jdbc:h2:" + this.dataDirectory.toFile().getAbsoluteFile() + "/limboauth");
+        this.connectionSource = new JdbcPooledConnectionSource("jdbc:h2:" + this.dataDirectoryFile.getAbsoluteFile() + "/limboauth");
         break;
       }
       case "mysql": {
-        Objects.requireNonNull(com.mysql.cj.jdbc.Driver.class);
-        Objects.requireNonNull(com.mysql.cj.conf.url.SingleConnectionUrl.class);
         this.connectionSource = new JdbcPooledConnectionSource(
             "jdbc:mysql://" + dbConfig.HOSTNAME + "/" + dbConfig.DATABASE + dbConfig.CONNECTION_PARAMETERS, dbConfig.USER, dbConfig.PASSWORD
         );
         break;
       }
       case "postgresql": {
-        Objects.requireNonNull(org.postgresql.Driver.class);
         this.connectionSource = new JdbcPooledConnectionSource(
             "jdbc:postgresql://" + dbConfig.HOSTNAME + "/" + dbConfig.DATABASE + dbConfig.CONNECTION_PARAMETERS, dbConfig.USER, dbConfig.PASSWORD
         );
         break;
       }
       default: {
-        this.getLogger().error("WRONG DATABASE TYPE.");
+        LOGGER.error("Wrong database type.");
         this.server.shutdown();
         return;
       }
@@ -271,7 +334,7 @@ public class LimboAuth {
             break;
           }
           default: {
-            this.getLogger().error("Incorrect world file type.");
+            LOGGER.error("Incorrect world file type.");
             this.server.shutdown();
             return;
           }
@@ -287,74 +350,84 @@ public class LimboAuth {
     this.authServer = this.factory
         .createLimbo(authWorld)
         .setName("LimboAuth")
-        .registerCommand(new AuthCommandMeta(this, this.filterCommands(Settings.IMP.MAIN.REGISTER_COMMAND)), new AuthCommand())
-        .registerCommand(new AuthCommandMeta(this, this.filterCommands(Settings.IMP.MAIN.LOGIN_COMMAND)), new AuthCommand())
-        .registerCommand(new AuthCommandMeta(this, this.filterCommands(Settings.IMP.MAIN.TOTP_COMMAND)), new AuthCommand());
+        .registerCommand(new LimboCommandMeta(this.filterCommands(Settings.IMP.MAIN.REGISTER_COMMAND)))
+        .registerCommand(new LimboCommandMeta(this.filterCommands(Settings.IMP.MAIN.LOGIN_COMMAND)))
+        .registerCommand(new LimboCommandMeta(this.filterCommands(Settings.IMP.MAIN.TOTP_COMMAND)));
 
-    this.server.getEventManager().unregisterListeners(this);
-    this.server.getEventManager().register(this, new AuthListener(this, this.playerDao, this.floodgateApi));
+    EventManager eventManager = this.server.getEventManager();
+    eventManager.unregisterListeners(this);
+    eventManager.register(this, new AuthListener(this, this.playerDao, this.floodgateApi));
 
-    Executors.newScheduledThreadPool(1, task -> new Thread(task, "purge-cache")).scheduleAtFixedRate(() ->
-            this.checkCache(this.cachedAuthChecks, Settings.IMP.MAIN.PURGE_CACHE_MILLIS),
+    Executors.newScheduledThreadPool(1, task -> new Thread(task, "purge-cache")).scheduleAtFixedRate(
+        () -> this.checkCache(this.cachedAuthChecks, Settings.IMP.MAIN.PURGE_CACHE_MILLIS),
         Settings.IMP.MAIN.PURGE_CACHE_MILLIS,
         Settings.IMP.MAIN.PURGE_CACHE_MILLIS,
         TimeUnit.MILLISECONDS
     );
 
-    Executors.newScheduledThreadPool(1, task -> new Thread(task, "purge-premium-cache")).scheduleAtFixedRate(() ->
-            this.checkCache(this.premiumCache, Settings.IMP.MAIN.PURGE_PREMIUM_CACHE_MILLIS),
+    Executors.newScheduledThreadPool(1, task -> new Thread(task, "purge-premium-cache")).scheduleAtFixedRate(
+        () -> this.checkCache(this.premiumCache, Settings.IMP.MAIN.PURGE_PREMIUM_CACHE_MILLIS),
         Settings.IMP.MAIN.PURGE_PREMIUM_CACHE_MILLIS,
         Settings.IMP.MAIN.PURGE_PREMIUM_CACHE_MILLIS,
         TimeUnit.MILLISECONDS
     );
 
-    this.server.getEventManager().fireAndForget(new AuthPluginReloadEvent());
+    eventManager.fireAndForget(new AuthPluginReloadEvent());
   }
 
   private List<String> filterCommands(List<String> commands) {
-    return commands.stream().filter(e -> e.startsWith("/")).map(e -> e.substring(1)).collect(Collectors.toList());
+    return commands.stream().filter(command -> command.startsWith("/")).map(command -> command.substring(1)).collect(Collectors.toList());
+  }
+
+  private void checkCache(Map<String, ? extends CachedUser> userMap, long time) {
+    userMap.entrySet().stream()
+        .filter(userEntry -> userEntry.getValue().getCheckTime() + time <= System.currentTimeMillis())
+        .map(Map.Entry::getKey)
+        .forEach(userMap::remove);
   }
 
   public void migrateDb(Dao<?, ?> dao) {
+    TableInfo<?, ?> tableInfo = dao.getTableInfo();
+
     Set<FieldType> tables = new HashSet<>();
-    Collections.addAll(tables, dao.getTableInfo().getFieldTypes());
+    Collections.addAll(tables, tableInfo.getFieldTypes());
 
     String findSql;
+    String database = Settings.IMP.DATABASE.DATABASE;
+    String tableName = tableInfo.getTableName();
     switch (Settings.IMP.DATABASE.STORAGE_TYPE) {
       case "h2": {
-        findSql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '"
-            + dao.getTableInfo().getTableName() + "';";
+        findSql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '" + tableName + "';";
         break;
       }
       case "postgresql": {
-        findSql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_CATALOG = '" + Settings.IMP.DATABASE.DATABASE
-            + "' AND TABLE_NAME = '" + dao.getTableInfo().getTableName() + "';";
+        findSql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_CATALOG = '" + database + "' AND TABLE_NAME = '" + tableName + "';";
         break;
       }
       case "mysql": {
-        findSql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '" + Settings.IMP.DATABASE.DATABASE
-            + "' AND TABLE_NAME = '" + dao.getTableInfo().getTableName() + "';";
+        findSql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '" + database + "' AND TABLE_NAME = '" + tableName + "';";
         break;
       }
       default: {
-        this.getLogger().error("WRONG DATABASE TYPE.");
+        LOGGER.error("WRONG DATABASE TYPE.");
         this.server.shutdown();
         return;
       }
     }
 
-    try {
-      dao.queryRaw(findSql).forEach(e -> tables.removeIf(q -> q.getColumnName().equalsIgnoreCase(e[0])));
+    try (GenericRawResults<String[]> queryResult = dao.queryRaw(findSql)) {
+      queryResult.forEach(result -> tables.removeIf(table -> table.getColumnName().equalsIgnoreCase(result[0])));
 
-      tables.forEach(t -> {
+      tables.forEach(table -> {
         try {
-          String columnDefinition = t.getColumnDefinition();
-          StringBuilder builder = new StringBuilder("ALTER TABLE \"" + dao.getTableInfo().getTableName() + "\" ADD ");
-          List<String> dummy = new ArrayList<>();
+          StringBuilder builder = new StringBuilder("ALTER TABLE \"" + tableName + "\" ADD ");
+          String columnDefinition = table.getColumnDefinition();
+          DatabaseType databaseType = dao.getConnectionSource().getDatabaseType();
           if (columnDefinition == null) {
-            dao.getConnectionSource().getDatabaseType().appendColumnArg(t.getTableName(), builder, t, dummy, dummy, dummy, dummy);
+            List<String> dummy = List.of();
+            databaseType.appendColumnArg(table.getTableName(), builder, table, dummy, dummy, dummy, dummy);
           } else {
-            dao.getConnectionSource().getDatabaseType().appendEscapedEntityName(builder, t.getColumnName());
+            databaseType.appendEscapedEntityName(builder, table.getColumnName());
             builder.append(" ").append(columnDefinition).append(" ");
           }
 
@@ -363,7 +436,7 @@ public class LimboAuth {
           e.printStackTrace();
         }
       });
-    } catch (SQLException e) {
+    } catch (Exception e) {
       e.printStackTrace();
     }
   }
@@ -372,7 +445,7 @@ public class LimboAuth {
     String username = player.getUsername();
     String lowercaseUsername = username.toLowerCase(Locale.ROOT);
     this.cachedAuthChecks.remove(lowercaseUsername);
-    this.cachedAuthChecks.put(lowercaseUsername, new CachedSessionUser(player.getRemoteAddress().getAddress(), username, System.currentTimeMillis()));
+    this.cachedAuthChecks.put(lowercaseUsername, new CachedSessionUser(System.currentTimeMillis(), player.getRemoteAddress().getAddress(), username));
   }
 
   public void removePlayerFromCache(String username) {
@@ -391,67 +464,52 @@ public class LimboAuth {
   }
 
   public void authPlayer(Player player) {
-    String nickname = player.getUsername();
     boolean isFloodgate = !Settings.IMP.MAIN.FLOODGATE_NEED_AUTH && this.floodgateApi.isFloodgatePlayer(player.getUniqueId());
+    String nickname = player.getUsername();
+    if (this.nicknameValidationPattern.matcher((isFloodgate) ? nickname.substring(this.floodgateApi.getPrefixLength()) : nickname).matches()) {
+      RegisteredPlayer registeredPlayer = AuthSessionHandler.fetchInfo(this.playerDao, nickname);
+      boolean onlineMode = player.isOnlineMode();
+      TaskEvent.Result result = TaskEvent.Result.NORMAL;
 
-    String validatorNickname = (isFloodgate) ? nickname.substring(this.floodgateApi.getPrefixLength()) : nickname;
-
-    if (!this.nicknameValidationPattern.matcher(validatorNickname).matches()) {
-      player.disconnect(LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.NICKNAME_INVALID_KICK));
-      return;
-    }
-
-    RegisteredPlayer registeredPlayer = AuthSessionHandler.fetchInfo(this.playerDao, nickname);
-    boolean onlineMode = player.isOnlineMode();
-    TaskEvent.Result result = TaskEvent.Result.NORMAL;
-
-    if (onlineMode || isFloodgate) {
-      if (registeredPlayer == null || registeredPlayer.getHash().isEmpty()) {
-        registeredPlayer = AuthSessionHandler.fetchInfo(this.playerDao, player.getUniqueId());
+      if (onlineMode || isFloodgate) {
         if (registeredPlayer == null || registeredPlayer.getHash().isEmpty()) {
-          // Due to the current connection state, which is set to LOGIN there, we cannot send the packets.
-          // We need to wait for the PLAY connection state to set.
-          this.postLoginTasks.put(player.getUniqueId(), () -> {
-            if (onlineMode) {
-              if (!Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM.isEmpty()) {
-                player.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM));
-              }
-              if (!Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_TITLE.isEmpty() && !Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_SUBTITLE.isEmpty()) {
-                player.showTitle(
-                    Title.title(
-                        LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_TITLE),
-                        LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_PREMIUM_SUBTITLE),
-                        Settings.IMP.MAIN.PREMIUM_TITLE_SETTINGS.toTimes()
-                    )
-                );
-              }
-            } else {
-              if (!Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE.isEmpty()) {
-                player.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE));
+          registeredPlayer = AuthSessionHandler.fetchInfo(this.playerDao, player.getUniqueId());
+          if (registeredPlayer == null || registeredPlayer.getHash().isEmpty()) {
+            // Due to the current connection state, which is set to LOGIN there, we cannot send the packets.
+            // We need to wait for the PLAY connection state to set.
+            this.postLoginTasks.put(player.getUniqueId(), () -> {
+              if (onlineMode) {
+                if (this.loginPremium != null) {
+                  player.sendMessage(this.loginPremium);
+                }
+                if (this.loginPremiumTitle != null) {
+                  player.showTitle(this.loginPremiumTitle);
+                }
+              } else {
+                if (this.loginFloodgate != null) {
+                  player.sendMessage(this.loginFloodgate);
+                }
+                if (this.loginFloodgateTitle != null) {
+                  player.showTitle(this.loginFloodgateTitle);
+                }
               }
-              if (!Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_TITLE.isEmpty() && !Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_SUBTITLE.isEmpty()) {
-                player.showTitle(
-                    Title.title(
-                        LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_TITLE),
-                        LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.LOGIN_FLOODGATE_SUBTITLE),
-                        Settings.IMP.MAIN.PREMIUM_TITLE_SETTINGS.toTimes()
-                    )
-                );
-              }
-            }
-          });
+            });
 
-          result = TaskEvent.Result.BYPASS;
+            result = TaskEvent.Result.BYPASS;
+          }
         }
       }
-    }
 
-    if (registeredPlayer == null) {
-      Consumer<TaskEvent> eventConsumer = (event) -> this.sendPlayer(event, null);
-      this.server.getEventManager().fire(new PreRegisterEvent(result, player, eventConsumer)).thenAcceptAsync(eventConsumer);
+      EventManager eventManager = this.server.getEventManager();
+      if (registeredPlayer == null) {
+        Consumer<TaskEvent> eventConsumer = (event) -> this.sendPlayer(event, null);
+        eventManager.fire(new PreRegisterEvent(eventConsumer, result, player)).thenAcceptAsync(eventConsumer);
+      } else {
+        Consumer<TaskEvent> eventConsumer = (event) -> this.sendPlayer(event, ((PreAuthorizationEvent) event).getPlayerInfo());
+        eventManager.fire(new PreAuthorizationEvent(eventConsumer, result, player, registeredPlayer)).thenAcceptAsync(eventConsumer);
+      }
     } else {
-      Consumer<TaskEvent> eventConsumer = (event) -> this.sendPlayer(event, ((PreAuthorizationEvent) event).getPlayerInfo());
-      this.server.getEventManager().fire(new PreAuthorizationEvent(result, player, registeredPlayer, eventConsumer)).thenAcceptAsync(eventConsumer);
+      player.disconnect(this.nicknameInvalidKick);
     }
   }
 
@@ -475,7 +533,7 @@ public class LimboAuth {
         try {
           this.authServer.spawnPlayer(player, new AuthSessionHandler(this.playerDao, player, this, registeredPlayer));
         } catch (Throwable t) {
-          this.getLogger().error("Error", t);
+          t.printStackTrace();
         }
 
         break;
@@ -492,26 +550,23 @@ public class LimboAuth {
     try {
       int statusCode = this.client.send(
           HttpRequest.newBuilder()
-              .uri(URI.create(
-                  String.format(
-                      Settings.IMP.MAIN.ISPREMIUM_AUTH_URL,
-                      URLEncoder.encode(lowercaseNickname, StandardCharsets.UTF_8))))
+              .uri(URI.create(String.format(Settings.IMP.MAIN.ISPREMIUM_AUTH_URL, URLEncoder.encode(lowercaseNickname, StandardCharsets.UTF_8))))
               .build(),
           HttpResponse.BodyHandlers.ofString()
       ).statusCode();
 
       boolean isPremium = statusCode == 200;
 
-      // 429 Too Many Requests
+      // 429 Too Many Requests.
       if (statusCode != 429) {
-        this.premiumCache.put(lowercaseNickname, new CachedPremiumUser(isPremium, System.currentTimeMillis()));
+        this.premiumCache.put(lowercaseNickname, new CachedPremiumUser(System.currentTimeMillis(), isPremium));
       } else {
         return Settings.IMP.MAIN.ON_RATE_LIMIT_PREMIUM;
       }
 
       return isPremium;
     } catch (IOException | InterruptedException e) {
-      this.getLogger().error("Unable to authenticate with Mojang", e);
+      LOGGER.error("Unable to authenticate with Mojang.", e);
       return Settings.IMP.MAIN.ON_RATE_LIMIT_PREMIUM;
     }
   }
@@ -519,43 +574,48 @@ public class LimboAuth {
   public boolean isPremium(String nickname) {
     if (Settings.IMP.MAIN.FORCE_OFFLINE_MODE) {
       return false;
-    }
-
-    try {
-      if (this.isPremiumExternal(nickname)) {
-        QueryBuilder<RegisteredPlayer, String> premiumRegisteredQuery = this.playerDao.queryBuilder();
-        premiumRegisteredQuery.where()
-            .eq("LOWERCASENICKNAME", nickname.toLowerCase(Locale.ROOT))
-            .and()
-            .ne("HASH", "");
-        premiumRegisteredQuery.setCountOf(true);
-
-        QueryBuilder<RegisteredPlayer, String> premiumUnregisteredQuery = this.playerDao.queryBuilder();
-        premiumUnregisteredQuery.where()
-            .eq("LOWERCASENICKNAME", nickname.toLowerCase(Locale.ROOT))
-            .and()
-            .eq("HASH", "");
-        premiumUnregisteredQuery.setCountOf(true);
-
-        if (Settings.IMP.MAIN.ONLINE_MODE_NEED_AUTH) {
-          return this.playerDao.countOf(premiumRegisteredQuery.prepare()) == 0 && this.playerDao.countOf(premiumUnregisteredQuery.prepare()) != 0;
+    } else {
+      try {
+        if (this.isPremiumExternal(nickname)) {
+          QueryBuilder<RegisteredPlayer, String> premiumRegisteredQuery = this.playerDao.queryBuilder();
+          premiumRegisteredQuery.where()
+              .eq("LOWERCASENICKNAME", nickname.toLowerCase(Locale.ROOT))
+              .and()
+              .ne("HASH", "");
+          premiumRegisteredQuery.setCountOf(true);
+
+          QueryBuilder<RegisteredPlayer, String> premiumUnregisteredQuery = this.playerDao.queryBuilder();
+          premiumUnregisteredQuery.where()
+              .eq("LOWERCASENICKNAME", nickname.toLowerCase(Locale.ROOT))
+              .and()
+              .eq("HASH", "");
+          premiumUnregisteredQuery.setCountOf(true);
+
+          if (Settings.IMP.MAIN.ONLINE_MODE_NEED_AUTH) {
+            return this.playerDao.countOf(premiumRegisteredQuery.prepare()) == 0 && this.playerDao.countOf(premiumUnregisteredQuery.prepare()) != 0;
+          } else {
+            return this.playerDao.countOf(premiumRegisteredQuery.prepare()) == 0;
+          }
         } else {
-          return this.playerDao.countOf(premiumRegisteredQuery.prepare()) == 0;
+          return false;
         }
-      } else {
-        return false;
+      } catch (Exception e) {
+        LOGGER.error("Unable to authenticate with Mojang.", e);
+        return Settings.IMP.MAIN.ON_RATE_LIMIT_PREMIUM;
       }
-    } catch (SQLException e) {
-      this.getLogger().error("Unable to authenticate with Mojang", e);
-      return Settings.IMP.MAIN.ON_RATE_LIMIT_PREMIUM;
     }
   }
 
-  private void checkCache(Map<String, ? extends CachedUser> userMap, long time) {
-    userMap.entrySet().stream()
-        .filter(u -> u.getValue().getCheckTime() + time <= System.currentTimeMillis())
-        .map(Map.Entry::getKey)
-        .forEach(userMap::remove);
+  public Map<UUID, Runnable> getPostLoginTasks() {
+    return this.postLoginTasks;
+  }
+
+  public Set<String> getUnsafePasswords() {
+    return this.unsafePasswords;
+  }
+
+  public ProxyServer getServer() {
+    return this.server;
   }
 
   public JdbcPooledConnectionSource getConnectionSource() {
@@ -566,20 +626,27 @@ public class LimboAuth {
     return this.playerDao;
   }
 
-  public Set<String> getUnsafePasswords() {
-    return this.unsafePasswords;
+  static {
+    // requireNonNull prevents the shade plugin from excluding the drivers in minimized jar.
+    Objects.requireNonNull(com.mysql.cj.jdbc.Driver.class);
+    Objects.requireNonNull(com.mysql.cj.conf.url.SingleConnectionUrl.class);
+
+    Objects.requireNonNull(org.h2.Driver.class);
+    Objects.requireNonNull(org.h2.engine.Engine.class);
+
+    Objects.requireNonNull(org.postgresql.Driver.class);
   }
 
-  public Map<UUID, Runnable> getPostLoginTasks() {
-    return this.postLoginTasks;
+  private static void setLogger(Logger logger) {
+    LOGGER = logger;
   }
 
-  public Logger getLogger() {
-    return this.logger;
+  private static void setSerializer(Serializer serializer) {
+    SERIALIZER = serializer;
   }
 
-  public ProxyServer getServer() {
-