lot of progress

common/src/main/java/us/ajg0702/queue/commands/BaseCommand.java

@@ -0,0 +1,59 @@
+package us.ajg0702.queue.commands;
+
+import com.google.common.collect.ImmutableList;
+import us.ajg0702.queue.api.commands.IBaseCommand;
+import us.ajg0702.queue.api.commands.ICommandSender;
+import us.ajg0702.queue.api.commands.ISubCommand;
+import us.ajg0702.utils.common.Messages;
+
+import java.util.List;
+
+public class BaseCommand implements IBaseCommand {
+    @Override
+    public String getName() {
+        return null;
+    }
+
+    @Override
+    public ImmutableList<String> getAliases() {
+        return null;
+    }
+
+    @Override
+    public ImmutableList<ISubCommand> getSubCommands() {
+        return null;
+    }
+
+    @Override
+    public String getPermission() {
+        return null;
+    }
+
+    @Override
+    public Messages getMessages() {
+        return null;
+    }
+
+    @Override
+    public void addSubCommand(ISubCommand subCommand) {
+
+    }
+
+    @Override
+    public void execute(ICommandSender sender, String[] args) {
+
+    }
+
+    public boolean checkPermission(ICommandSender sender) {
+        if(getPermission() != null && !sender.hasPermission(getPermission())) {
+            sender.sendMessage(getMessages().getComponent("noperm"));
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public List<String> autoComplete(ICommandSender sender, String[] args) {
+        return null;
+    }
+}

common/src/main/java/us/ajg0702/queue/commands/SubCommand.java

@@ -0,0 +1,7 @@
+package us.ajg0702.queue.commands;
+
+import us.ajg0702.queue.api.commands.ISubCommand;
+
+public class SubCommand extends BaseCommand implements ISubCommand {
+
+}

common/src/main/java/us/ajg0702/queue/commands/commands/queue/QueueCommand.java

@@ -0,0 +1,82 @@
+package us.ajg0702.queue.commands.commands.queue;
+
+import com.google.common.collect.ImmutableList;
+import us.ajg0702.queue.api.commands.ICommandSender;
+import us.ajg0702.queue.api.commands.ISubCommand;
+import us.ajg0702.queue.api.players.AdaptedPlayer;
+import us.ajg0702.queue.commands.BaseCommand;
+import us.ajg0702.queue.common.QueueMain;
+import us.ajg0702.utils.common.Messages;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class QueueCommand extends BaseCommand {
+
+    private final QueueMain main;
+
+    public QueueCommand(QueueMain main) {
+        this.main = main;
+    }
+
+    @Override
+    public String getName() {
+        return "queue";
+    }
+
+    @Override
+    public ImmutableList<String> getAliases() {
+        return ImmutableList.of("move", "server", "joinqueue", "joinq");
+    }
+
+    @Override
+    public ImmutableList<ISubCommand> getSubCommands() {
+        return ImmutableList.<ISubCommand>builder().build();
+    }
+
+    @Override
+    public String getPermission() {
+        return null;
+    }
+
+    @Override
+    public Messages getMessages() {
+        return main.getMessages();
+    }
+
+    @Override
+    public void addSubCommand(ISubCommand subCommand) {
+
+    }
+
+    @Override
+    public void execute(ICommandSender sender, String[] args) {
+        if(!checkPermission(sender)) return;
+        if(!sender.isPlayer()) {
+            sender.sendMessage(getMessages().getComponent("errors.player-only"));
+            return;
+        }
+        AdaptedPlayer player = main.getPlatformMethods().senderToPlayer(sender);
+
+        if(args.length > 0) {
+            if(main.getConfig().getBoolean("require-permission") && !player.hasPermission("ajqueue.queue."+args[0])) {
+                sender.sendMessage(getMessages().getComponent("noperm"));
+                return;
+            }
+            main.getQueueManager().addToQueue(player, args[0]);
+        } else {
+            sender.sendMessage(getMessages().getComponent("commands.joinqueue.usage"));
+        }
+    }
+
+    @Override
+    public List<String> autoComplete(ICommandSender sender, String[] args) {
+        if(!main.getConfig().getBoolean("tab-complete-queues")) {
+            return new ArrayList<>();
+        }
+        if(args.length == 1) {
+            return main.getQueueManager().getServerNames();
+        }
+        return new ArrayList<>();
+    }
+}

common/src/main/java/us/ajg0702/queue/common/QueueMain.java

@@ -1,12 +1,20 @@
 package us.ajg0702.queue.common;
 
 import org.spongepowered.configurate.ConfigurateException;
-import us.ajg0702.queue.api.*;
+import us.ajg0702.queue.api.AliasManager;
+import us.ajg0702.queue.api.Logic;
+import us.ajg0702.queue.api.PlatformMethods;
+import us.ajg0702.queue.api.QueueManager;
+import us.ajg0702.queue.api.server.ServerBuilder;
+import us.ajg0702.queue.logic.LogicGetter;
 import us.ajg0702.utils.common.Config;
 import us.ajg0702.utils.common.Messages;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
 import java.util.logging.Logger;
 
 public class QueueMain {
@@ -41,20 +49,36 @@ public class QueueMain {
         return getLogic().isPremium();
     }
 
-    private PlatformMethods platformMethods;
+    private final PlatformMethods platformMethods;
     public PlatformMethods getPlatformMethods() {
         return platformMethods;
     }
 
-    private Logger logger;
+    private final Logger logger;
     public Logger getLogger() {
         return logger;
     }
 
+    private List<CompletableFuture<ServerBuilder>> serverCompletableFutures = new ArrayList<>();
     private ServerBuilder serverBuilder;
     public ServerBuilder getServerBuilder() {
         return serverBuilder;
     }
+    public CompletableFuture<ServerBuilder> getFutureServerBuilder() {
+        CompletableFuture<ServerBuilder> completableFuture = new CompletableFuture<>();
+        if(serverBuilder != null) {
+            completableFuture.complete(serverBuilder);
+        }
+        serverCompletableFutures.add(completableFuture);
+        return completableFuture;
+    }
+    public void setServerBuilder(ServerBuilder serverBuilder) {
+        if(this.serverBuilder != null) throw new IllegalStateException("SeverBuilder already set");
+        this.serverBuilder = serverBuilder;
+        for(CompletableFuture<ServerBuilder> future : serverCompletableFutures) {
+            future.complete(serverBuilder);
+        }
+    }
 
     private QueueManager queueManager;
     public QueueManager getQueueManager() {
@@ -62,10 +86,15 @@ public class QueueMain {
     }
 
 
-    public QueueMain(Logger logger, ServerBuilder serverBuilder, PlatformMethods platformMethods, File dataFolder) {
+    private File dataFolder;
+
+
+    public QueueMain(Logger logger, PlatformMethods platformMethods, File dataFolder) {
         this.logger = logger;
-        this.serverBuilder = serverBuilder;
         this.platformMethods = platformMethods;
+        this.dataFolder = dataFolder;
+
+        constructMessages();
 
         try {
             config = new Config(dataFolder, logger);
@@ -79,7 +108,14 @@ public class QueueMain {
 
         queueManager = new QueueManagerImpl(this);
 
+        logic = new LogicGetter().constructLogic();
+        aliasManager = new LogicGetter().constructAliasManager(config);
 
+
+
+    }
+
+    private void constructMessages() {
         LinkedHashMap<String, String> d = new LinkedHashMap<>();
 
         d.put("status.offline.base", "&c{SERVER} is {STATUS}. &7You are in position &f{POS}&7 of &f{LEN}&7.");

common/src/main/java/us/ajg0702/queue/common/QueueManagerImpl.java

@@ -6,13 +6,14 @@ import us.ajg0702.queue.api.players.AdaptedPlayer;
 import us.ajg0702.queue.api.players.QueuePlayer;
 import us.ajg0702.queue.api.queues.QueueServer;
 import us.ajg0702.queue.api.server.AdaptedServer;
-import us.ajg0702.queue.api.server.AdaptedServerInfo;
+import us.ajg0702.queue.api.server.ServerBuilder;
 import us.ajg0702.queue.common.players.QueuePlayerImpl;
-import us.ajg0702.utils.bungee.BungeeUtils;
 import us.ajg0702.utils.common.Messages;
 import us.ajg0702.utils.common.TimeUtils;
 
 import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 
 public class QueueManagerImpl implements QueueManager {
 
@@ -24,6 +25,16 @@ public class QueueManagerImpl implements QueueManager {
     public QueueManagerImpl(QueueMain main) {
         this.main = main;
         this.msgs = main.getMessages();
+
+        CompletableFuture<ServerBuilder> serverBuilderFuture = main.getFutureServerBuilder();
+        serverBuilderFuture.thenRunAsync(() -> {
+            try {
+                servers = serverBuilderFuture.get().buildServers();
+                // TODO: groups
+            } catch (InterruptedException | ExecutionException e) {
+                e.printStackTrace();
+            }
+        });
     }
 
     @Override
@@ -107,12 +118,14 @@ public class QueueManagerImpl implements QueueManager {
                         "SERVER:"+server.getAlias()));
             }
         } else {
-            player.sendMessage(msgs.getComponent("status.now-in-queue",
-                    "POS:"+pos,
-                    "LEN:"+len,
-                    "SERVER:"+server.getAlias(),
-                    "SERVERNAME:"+server.getName()
-            ));
+            player.sendMessage(
+                    msgs.getComponent("status.now-in-queue",
+                      "POS:"+pos,
+                       "LEN:"+len,
+                        "SERVER:"+server.getAlias(),
+                       "SERVERNAME:"+server.getName()
+                    )
+            );
         }
 
         main.getPlatformMethods().sendJoinQueueChannelMessages(server, queuePlayer);
@@ -167,7 +180,7 @@ public class QueueManagerImpl implements QueueManager {
 
         servers.clear();
 
-        servers.addAll(main.getServerBuilder().getServers());
+        servers.addAll(main.getServerBuilder().buildServers());
 
         List<String> groupsraw = main.getConfig().getStringList("server-groups");
         for(String groupraw : groupsraw) {

common/src/main/resources/config.yml

@@ -0,0 +1,174 @@
+# Dont touch this number please
+config-version: 21
+
+# The time the server will wait between sending people in the queue
+#  Default: 5
+wait-time: 5
+
+# The time that a server has to be offline to be marked as offline instead of restarting
+#  Default: 120
+offline-time: 120
+
+# The time the server will wait between sending players update messages on what position they are in the queue.
+# Default: 10
+message-time: 10
+
+# If a player is in a server, you can have the plugin make them automatically join a queue for another server
+# Example with the default values: Player joins survivalqueue server, they will auto-join the queue for survival
+queue-servers:
+  - 'survivalqueue:survival'
+
+# Should the plugin send an actionbar to the player?
+# The actionbar contains some info such as which server they are queued for, what position they are in, estimated time remaining, etc.
+send-actionbar: true
+
+# What kick reasons should cause the player to be removed from the queue?
+# For example, if one of the below kick reasons is 'banned' and the player gets kicked when trying to connect to
+#  a server in a queue with a message saying "You are banned from this server!" then it will kick them from the queue too.
+kick-reasons:
+  - 'banned'
+  - 'blacklisted'
+
+
+# Should we remove a player from the queue if they move servers?
+# If they join another queue, they will be removed from the previous one no matter what
+# This is more meant for if you have multiple lobbies if you want to let the player switch
+# between them without losing their queue position
+#  Default: false
+remove-player-on-server-switch: false
+
+
+# Should we wait until the server is done loading to load the servers?
+# Enable this if you have a plugin that adds servers to the server list during startup.
+#  Default: false
+wait-to-load-servers: false
+
+# How long should we wait after the server finishes loading to load the server list?
+# Only works if the above is enabled.
+# This is in miliseconds so 1000 = 1 second
+#  Default: 500
+wait-to-load-servers-delay: 500
+
+
+# How often (in seconds) we should check for new servers to add queues for.
+# If you dynamicly add servers, set this to something other than 0.
+# To disable, set to 0
+reload-servers-interval: 0
+
+
+# Should we require permissions for players to be able to join queues?
+# If enabled, players will be required to have the permission ajqueue.queue.<server>
+#  Default: false
+require-permission: false
+
+
+# Should we let players join more than one queue?
+# If enabled, players will be able to be in multiple queues at once.
+#  Default: true
+allow-multiple-queues: true
+
+# If the player is queued for multiple servers, which server should we pick to use in things like placeholders and actionbars
+# Options are first and last
+#  Default: last
+multi-server-queue-pick: last
+
+
+# THIS FEATURE IS ONLY AVAILABLE ON ajQueuePlus (https://www.spigotmc.org/resources/ajqueueplus.79123/)
+# This will show players a different name than the actual bungeecord server name
+# for example, instead of showing players "event-a", this option can make it appear as "Event A"
+# With this example, you would use this: - "event-a:Event A"
+# Note that currently players still have to use the normal names in queue commands and leave commands
+#  Format: "realname:Alias"
+server-aliases:
+  - "event-a:Event A"
+
+
+# How long should we wait after a server is online before sending players?
+# The server will still show up as offline or restarting until this amount of time after its up
+# Meant to let your server 'cool down' after lag from starting up
+# In seconds
+#  Default: 1
+wait-after-online: 1
+
+
+# This is for helping with finding issues with the server pinged
+# This will spam the console when enabled
+# When this enabled, if servers are offline then it will spam errors. You can ignore them.
+#  Default: false
+pinger-debug: false
+
+
+# When a queue is paused, should we prevent players from joining it?
+#  Default: false
+prevent-joining-paused: false
+
+# When a server goes back online, should we send all players in the queue instantly?
+# Default: false
+send-all-when-back-online: false
+
+# Require a permission for players to be able to join a queue from a server
+# If enabled, players will need the permission ajqueue.joinfrom.<server> to join queues.
+# Replace <server> with the name of the server
+#  Default: false
+joinfrom-server-permission: false
+
+# Server groups are a group of servers that you can queue for. It will send you to the server that is the least full.
+# If all servers in the group are full, it will act the same as it would when a single server is full.
+# Same if all servers are offline. It will only send players to servers that are online.
+#  Format: "groupname:server1,server2,etc"
+server-groups:
+  - "lobbys:lobby-1,lobby-2,lobby-3"
+
+
+# Should we allow tab-completing in the /queue command?
+#  Default: true
+tab-complete-queues: true
+
+# Should we have no wait time for these servers?
+# If the server is joinable, the plugin will attempt to send players who join these queues as soon as they join.
+# If the server is not immidiatly joinable, they will have to wait for the normal wait-time
+# This also works with group
+# NOTE: Server names are caps sensitive
+send-instantly:
+  - "lobbys"
+
+# Should we log to the bungeecord console when a player fails to get sent to a server from the queue?
+# Enable this if you are having an issue with one player stopping the queue
+#  Default: false
+send-fail-debug: false
+
+# After how many (unsuccessfull) attempts of sending the player should we remove them from the queue?
+# Set to -1 to disable
+#  Default: 10
+max-tries: 10
+
+# Should we enable the ajqueue.bypasspaused permission?
+# If enabled, anyone with the permission ajqueue.bypasspaused will be able to join paused servers
+#  Default: false
+enable-bypasspaused-permission: false
+
+# Should we check to make sure that people dont get sent quicker than wait-time?
+#  Default: true
+check-last-player-sent-time: true
+
+# Should we send debug info to the console when priority queue is used?
+# This will print several lines to the console when a player joins a queue,
+# so you should probably only use this for debugging purposes
+#  Default: false
+priority-queue-debug: false
+
+# When a player is kicked from a server, should we automatically add that player to the queue?
+# You will still need to use another plugin to make sure the player doesnt get kicked from bungee completly.
+#  Default: false
+auto-add-to-queue-on-kick: false
+# The delay for the above option.
+# In seconds, decimals supported.
+auto-add-to-queue-on-kick-delay: 1
+
+# With what kick reasons should we auto-add the player to the queue
+# This wont work if auto-add-to-queue-on-kick is disabled.
+# If you set it to [], then all kick messages will cause the player to be added to the queue
+# This works on contains, so you dont have to include the whole kick message, just a few words.
+auto-add-kick-reasons:
+  - "restarting"
+  - "closed"