Improve SendCommand

VelocityCore/src/de/steamwar/velocitycore/commands/SendCommand.java

@@ -20,6 +20,7 @@
 package de.steamwar.velocitycore.commands;
 
 import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ServerConnection;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 import com.velocitypowered.api.proxy.server.ServerInfo;
 import de.steamwar.command.PreviousArguments;
@@ -33,23 +34,46 @@ import de.steamwar.velocitycore.VelocityCore;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class SendCommand extends SWCommand {
 
+    // /send from <server> to <server> [only <users>]
+    // /send to <server> only [<users>]
+    // <server> can also be current
+
     public SendCommand() {
         super("send", UserPerm.TEAM);
     }
 
     @Register
-    public void sendToServer(Chatter sender, Player send, RegisteredServer server) {
-        send.createConnectionRequest(server).fireAndForget();
+    public void sendCommand(Chatter sender, @StaticValue("from") String from, RegisteredServer fromServer, @StaticValue("to") String to, RegisteredServer toServer) {
+        sendPlayers(toServer, fromServer.getPlayersConnected());
+    }
+
+    @Register
+    public void sendCommand(Chatter sender, @StaticValue("from") String from, RegisteredServer fromServer, @StaticValue("to") String to, RegisteredServer toServer, @StaticValue("only") String only, @ArrayLength(min = 1) Player... players) {
+        sendPlayers(toServer, List.of(players));
+    }
+
+    @Register
+    public void sendCommand(Chatter sender, @StaticValue("to") String to, RegisteredServer toServer, @StaticValue("only") String only, @ArrayLength(min = 1) Player... players) {
+        sendPlayers(toServer, List.of(players));
+    }
+
+    private void sendPlayers(RegisteredServer toServer, Collection<Player> players) {
+        for (Player player : players) {
+            player.createConnectionRequest(toServer).fireAndForget();
+        }
     }
 
     @ClassMapper(value = RegisteredServer.class, local = true)
     public TypeMapper<RegisteredServer> subserverTypeMapper() {
         return new TypeMapper<>() {
             private boolean check(SteamwarUser user, RegisteredServer registeredServer) {
+                if (registeredServer == null) return false;
                 ServerInfo serverInfo = registeredServer.getServerInfo();
                 String name = serverInfo.getName();
                 if (name.contains(" ")) return false;
@@ -66,20 +90,64 @@ public class SendCommand extends SWCommand {
                         return registeredServer;
                     }
                 }
+
+                RegisteredServer currentServer = sender.getPlayer().getCurrentServer().map(ServerConnection::getServer).orElse(null);
+                if (s.equals("current") && check(user, currentServer)) {
+                    return currentServer;
+                }
                 return null;
             }
 
             @Override
             public Collection<String> tabCompletes(Chatter sender, PreviousArguments previousArguments, String s) {
                 SteamwarUser user = sender.user();
+                List<RegisteredServer> previous = previousArguments.getAll(RegisteredServer.class);
+
                 List<String> tabCompletes = new ArrayList<>();
                 for (RegisteredServer registeredServer : VelocityCore.getProxy().getAllServers()) {
+                    if (previous.contains(registeredServer)) continue;
                     if (check(user, registeredServer)) {
                         tabCompletes.add(registeredServer.getServerInfo().getName());
                     }
                 }
+
+                Player player = sender.getPlayer();
+                if (player != null) {
+                    RegisteredServer currentServer = player.getCurrentServer().map(ServerConnection::getServer).orElse(null);
+                    if (currentServer != null && !previous.contains(currentServer) && check(user, currentServer)) {
+                        tabCompletes.add("current");
+                    }
+                }
+
                 return tabCompletes;
             }
         };
     }
+
+    @ClassMapper(value = Player.class, local = true)
+    public TypeMapper<Player> playerTypeMapper() {
+        return new TypeMapper<>() {
+            @Override
+            public Player map(Chatter sender, PreviousArguments previousArguments, String s) {
+                return VelocityCore.getProxy().getPlayer(s).orElse(null);
+            }
+
+            @Override
+            public Collection<String> tabCompletes(Chatter sender, PreviousArguments previousArguments, String s) {
+                List<RegisteredServer> previous = previousArguments.getAll(RegisteredServer.class);
+                if (previous.isEmpty()) {
+                    return VelocityCore.getProxy().getAllPlayers().stream().map(Player::getUsername).collect(Collectors.toList());
+                }
+                if (previous.size() == 1) {
+                    Collection<Player> players = previous.get(0).getPlayersConnected();
+                    return VelocityCore.getProxy().getAllPlayers().stream().filter(player -> !players.contains(player)).map(Player::getUsername).collect(Collectors.toList());
+                }
+                if (previous.size() == 2) {
+                    Collection<Player> players = previous.get(0).getPlayersConnected();
+                    return players.stream().map(Player::getUsername).collect(Collectors.toList());
+                }
+                return Collections.emptyList();
+            }
+        };
+    }
 }