feat: better readme

.settings/org.eclipse.buildship.core.prefs

@@ -1,4 +1,4 @@
-arguments=--init-script /home/xeon0x/.var/app/dev.zed.Zed/data/zed/extensions/work/java/jdtls/jdt-language-server-1.46.0-202503271314/configuration/org.eclipse.osgi/58/0/.cp/gradle/init/init.gradle
+arguments=--init-script /home/xeon0x/.var/app/dev.zed.Zed/data/zed/extensions/work/java/jdtls/jdt-language-server-1.46.1-202504011455/configuration/org.eclipse.osgi/58/0/.cp/gradle/init/init.gradle
 auto.sync=false
 build.scans.enabled=false
 connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)

README.md

@@ -1,5 +1,24 @@
 # ClientServer
 
+A Java-based ☕️↔️ UDP client-server chat 💬 system with automatic 🔄 text-to-emoji 😊 conversion using Mistral API.
+
+## Features
+
+### Available Commands
+
+- `/list` : Display connected clients list
+- `/msg <nickname> <message>` : Send private message to specific client
+- `/help` : Display help with all available commands
+- `/disconnect` : Clean server disconnection
+- `<message>` : Broadcast message translated to emojis to all connected clients
+
+### Technical Features
+
+- UDP Communication
+- Multi-threading for client handling
+- Mistral API for text-to-emoji conversion
+- Disconnection handling
+
 ## Build
 
 ```bash
@@ -11,33 +30,76 @@
 ### Client
 
 ```bash
-./gradlew run --args='client'
+./gradlew runClient
 ```
 
-or
+The client will ask for a pseudo, an IP (type `localhost` if server and clients are on the same machine), and a port (type `6666` by default).
-
-```bash
-./gradlew runServer
-```
 
 ### Server
 
-```bash
-./gradlew run --args='server'
-```
-
-or
-
 ```bash
 ./gradlew runServer
 ```
 
+## Configuration
+
+Create a `config.properties` file at project root (`ClientServer/app/config.properties`) with:
+
+```properties
+mistral.api.key=your_api_key
+```
+
+Replace `your_api_key` with your actual Mistral API key. Create one for free at https://console.mistral.ai/api-keys. If no API key is provided, the server will not be able to convert broadcasted messages to emojis and empty broadcasted messages will be sent.
+
 ## Documentation
 
+### Sequence Diagram
+
 ```mermaid
 sequenceDiagram
-    Note over Client, Serveur: DatagramSocket("localhost", 66666)
+    participant MainServer
-    Client->>+Serveur: DatagramPacket("Salve !", 7, "localhost", 6666)
+
-    Note over Serveur, Client: DatagramSocket("localhost", 66666)
+    participant Alice
-    Serveur->>+Client: DatagramPacket("Accusé de réception", 19, "localhost", 6666)
+    Note over Alice: Creates DatagramSocket
+    Alice->>+MainServer: Sends username "Alice"
+    Note over MainServer: Creates new socket<br/>for AliceHandler
+    create participant AliceHandler
+    MainServer->>AliceHandler: Create new handler thread
+    MainServer->>-Alice: PORT:{AlicePort}
+
+    participant Bob
+    Bob->>+MainServer: Sends username "Bob"
+    Note over MainServer: Creates new socket<br/>for BobHandler
+    create participant BobHandler
+    MainServer->>BobHandler: Create new handler thread
+    MainServer->>-Bob: PORT:{BobPort}
+
+    rect rgb(200, 200, 255)
+        Note over Alice,Bob: Chat loop
+        Alice->>+AliceHandler: "Hi everyone!"
+        Note over AliceHandler: Converts to emojis
+        AliceHandler->>+BobHandler: Broadcast message
+        BobHandler->>-Bob: "Alice: 👋👩‍👩🌍🎉"
+        AliceHandler->>-Alice: Message sent
+
+        Bob->>+BobHandler: "Hello Alice, how are you?"
+        Note over BobHandler: Converts to emojis
+        BobHandler->>+AliceHandler: Broadcast message
+        AliceHandler->>-Alice: "Bob: 👋🏻👩🏼‍🦰🐰🤔👩🏼‍🦰🐇💬👩🏼‍🦰🐰👍🏻😊👩🏼‍🦰🐇👋🏻"
+        BobHandler->>-Bob: Message sent
+    end
+
+    Alice->>+AliceHandler: /disconnect
+    Note over AliceHandler: Removes Alice<br/>from map
+    AliceHandler->>-Alice: Disconnection confirmation
+    AliceHandler->>MainServer: Thread terminated
+    MainServer-->>AliceHandler: destroy
+
+    Bob->>+BobHandler: /disconnect
+    Note over BobHandler: Removes Bob<br/>from map
+    BobHandler->>-Bob: Disconnection confirmation
+    BobHandler->>MainServer: Thread terminated
+    MainServer-->>BobHandler: destroy
+
+    Note over Alice,Bob: Close sockets
 ```

app/build.gradle

@@ -55,4 +55,5 @@ task runClient(type: JavaExec) {
     mainClass = application.mainClass
     classpath = sourceSets.main.runtimeClasspath
     args = ['--client']
+    standardInput = System.in
 }

app/src/main/java/clientserver/client/Client.java

@@ -1,14 +1,78 @@
 package clientserver.client;
 
+import clientserver.server.Server;
+import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
-import java.util.concurrent.TimeUnit;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.util.Scanner;
 
 public class Client {
 
     InetAddress clientAddress;
     int clientPort;
+    private InetAddress serverAddress;
+    private int serverPort;
+    private String pseudo;
+    private Scanner scan;
+    private DatagramSocket clientSocket;
+    private int handlerPort;
+
+    public Client(InetAddress address, int port) {
+        this.clientAddress = address;
+        this.clientPort = port;
+    }
+
+    private static class MessageReceiver implements Runnable {
+
+        private final DatagramSocket socket;
+        private volatile boolean running = true;
+
+        public MessageReceiver(DatagramSocket socket) {
+            this.socket = socket;
+        }
+
+        @Override
+        public void run() {
+            try {
+                socket.setSoTimeout(500); // Petit timeout pour pouvoir vérifier régulièrement si on doit s'arrêter,
+                // evite thread zombie car receive() est bloquant
+
+                while (running && !socket.isClosed()) {
+                    try {
+                        byte[] buffer = new byte[1024];
+                        DatagramPacket packet = new DatagramPacket(
+                            buffer,
+                            buffer.length
+                        );
+
+                        socket.receive(packet);
+                        String message = new String(
+                            packet.getData(),
+                            0,
+                            packet.getLength()
+                        );
+
+                        // Afficher le message reçu avec une mise en forme claire
+                        System.out.println(message);
+                    } catch (SocketTimeoutException e) {}
+                }
+            } catch (IOException e) {
+                if (!socket.isClosed()) {
+                    System.err.println(
+                        "Error in the reception of messages: " + e.getMessage()
+                    );
+                }
+            }
+            System.out.println("Message receiver stopped");
+        }
+
+        public void stop() {
+            running = false;
+        }
+    }
 
     public void setPort(int port) {
         this.clientPort = port;
@@ -22,66 +86,196 @@ public class Client {
         return this.clientAddress;
     }
 
-    public Client(InetAddress address, int port) {
+    public InetAddress getServerAddress() {
-        this.clientAddress = address;
+        return this.serverAddress;
-        this.clientPort = port;
+    }
+
+    public int getServerPort() {
+        return this.serverPort;
+    }
+
+    public void setServerPort(int port) {
+        this.serverPort = port;
+    }
+
+    public String getPseudo() {
+        return this.pseudo;
+    }
+
+    public void setPseudo(String pseudo) {
+        this.pseudo = pseudo;
+    }
+
+    public Scanner getScanner() {
+        return this.scan;
+    }
+
+    public void setScanner(Scanner scan) {
+        this.scan = scan;
+    }
+
+    public DatagramSocket getClientSocket() {
+        return this.clientSocket;
+    }
+
+    public void setClientSocket(DatagramSocket clientSocket) {
+        this.clientSocket = clientSocket;
+    }
+
+    public int getHandlerPort() {
+        return handlerPort;
+    }
+
+    public void setHandlerPort(int handlerPort) {
+        this.handlerPort = handlerPort;
+    }
+
+    public static Client createAndConfigureClient(DatagramSocket socketClient) {
+        System.out.println("Enter your Pseudo :");
+
+        // Créer le client avec l'adresse locale et le port du socket
+        Client client = new Client(
+            socketClient.getLocalAddress(),
+            socketClient.getLocalPort()
+        );
+        client.setScanner(new Scanner(System.in));
+        String userPseudo = client.getScanner().next();
+        client.setPseudo(userPseudo);
+
+        System.out.println("Enter the IP address of the server :");
+        try {
+            client.serverAddress = InetAddress.getByName(
+                client.getScanner().next()
+            );
+        } catch (UnknownHostException e) {
+            System.err.println(
+                "The address you choose create an UnknownHostException: " + e
+            );
+        }
+
+        System.out.println("Enter the port of the server:");
+        client.setServerPort(client.getScanner().nextInt());
+        client.getScanner().nextLine(); // Consume the remaining newline to avoid sending a void line message like
+        // (morph (/127.0.0.1:39056) : ...)
+
+        if (socketClient != null && client.serverAddress != null) {
+            Server.sendMessage(
+                socketClient,
+                client.getPseudo(),
+                client.serverAddress,
+                client.getServerPort()
+            );
+            System.out.println("New connection request sent");
+        }
+
+        return client;
+    }
+
+    private static void deconnexionClient(
+        DatagramSocket socketClient,
+        Client client,
+        int handlerPort
+    ) {
+        try {
+            String disconnectMsg = "/disconnect";
+            byte[] disconnectData = disconnectMsg.getBytes();
+            DatagramPacket disconnectPacket = new DatagramPacket(
+                disconnectData,
+                disconnectData.length,
+                client.getServerAddress(),
+                handlerPort
+            );
+            socketClient.send(disconnectPacket);
+            System.out.println(
+                "Deconnection sended on the server port: " + handlerPort
+            );
+        } catch (Exception e) {
+            System.err.println(
+                "Error during sending the deconnection message: " + e
+            );
+        }
+    }
+
+    public void run() {
+        // 1 - Boucle principale pour l'envoi des messages
+        boolean running = true;
+
+        System.out.println("\n=== Chat client ready ===");
+        // System.out.println(
+        //     "Type your messages then press 'Enter' to send them to the server."
+        // );
+        System.out.println("Type /list to see all the clients connected.");
+        System.out.println(
+            "Type '/msg <target> <message>' to send a private message."
+        );
+        System.out.println("Type '/help' to see all the commands.");
+        System.out.println("Type '/disconnect' to quit.\n");
+
+        while (running) {
+            String message = this.getScanner().nextLine();
+
+            if ("/disconnect".equalsIgnoreCase(message)) {
+                running = false;
+            } else {
+                Server.sendMessage(
+                    this.clientSocket,
+                    message,
+                    this.getServerAddress(),
+                    this.getHandlerPort()
+                );
+            }
+        }
+
+        // 2 - Gérer la déconnexion proprement
+        System.out.println("Deconnection in progress...");
+        deconnexionClient(this.getClientSocket(), this, this.getHandlerPort());
     }
 
     public static void main(String[] args) {
         try {
             // 1 - Création du canal avec un port libre
             DatagramSocket socketClient = new DatagramSocket();
-            InetAddress serverAddress = InetAddress.getByName("localhost");
-            int serverPort = 6666;
 
-            // 2 - Envoyer un message au serveur
+            // 2 - Création du client avec l'envoi du pseudo pour l'établissement de la
-            String message = "Connection request";
+            // connexion
-            byte[] sendData = message.getBytes();
+            Client client = createAndConfigureClient(socketClient);
-            DatagramPacket sendPacket = new DatagramPacket(
-                sendData,
-                sendData.length,
-                serverAddress,
-                serverPort
-            );
-            socketClient.send(sendPacket);
-            System.out.println("New connection request sent");
 
-            // 3 - Recevoir
+            // 3 - Recevoir la réponse initiale du serveur
-            byte[] receivedData = new byte[1024]; // tampon de réception
+            DatagramPacket receivedPacket = Server.receivedPacket(socketClient);
-            DatagramPacket receivedPacket = new DatagramPacket(
+            String reponse = Server.packetToMessage(receivedPacket);
-                receivedData,
-                receivedData.length
-            );
-            socketClient.receive(receivedPacket);
-            String reponse = new String(
-                receivedPacket.getData(),
-                0,
-                receivedPacket.getLength()
-            );
 
             if (reponse.startsWith("PORT:")) {
-                int newPort = Integer.parseInt(reponse.substring(5));
+                int handlerPort = Integer.parseInt(reponse.substring(5));
+                System.out.println("Connected on handler port: " + handlerPort);
 
-                System.out.println("Connected on port:" + newPort);
+                client.setClientSocket(socketClient);
+                client.setHandlerPort(handlerPort);
 
-                // 4 - Communiquer sur le nouveau port
+                // 4 - Lancer uniquement le thread de réception des messages
-                for (int i = 0; i < 20; i++) {
+                MessageReceiver receiver = new MessageReceiver(socketClient);
-                    String messagePort = "Test";
+                Thread receiverThread = new Thread(receiver);
-                    byte[] envoyeesPort = messagePort.getBytes();
+                receiverThread.setDaemon(true);
-                    DatagramPacket paquetPort = new DatagramPacket(
+                receiverThread.start();
-                        envoyeesPort,
+
-                        envoyeesPort.length,
+                // 5 - Éxecution du client, bloquant tant que le client est connecté.
-                        serverAddress,
+                client.run();
-                        newPort
+
+                // 6 - Arrêter le thread de réception
+                receiver.stop();
+                try {
+                    receiverThread.join(1000);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            } else {
+                System.err.println(
+                    "Unexpected response from the server: " + reponse
                 );
-                    socketClient.send(paquetPort);
-                    System.out.println("Test sent");
-                    TimeUnit.SECONDS.sleep(1);
-                }
             }
 
-            // 5 - Libérer le canal
+            // 8 - Libérer le canal
             socketClient.close();
+            System.out.println("Client closed");
         } catch (Exception e) {
             System.err.println(e);
         }

app/src/main/java/clientserver/common/MistralDirectAPI.java

@@ -10,10 +10,9 @@ import java.util.Properties;
 
 public class MistralDirectAPI {
 
-    public static void main(String[] args) {
+    private static String apiKey;
-        String apiKey;
 
-        // Load API key from properties file
+    static {
         try {
             Properties props = new Properties();
             FileInputStream input = new FileInputStream("config.properties");
@@ -22,18 +21,22 @@ public class MistralDirectAPI {
             input.close();
         } catch (IOException e) {
             System.err.println("Could not load API key: " + e.getMessage());
-            return;
+        }
     }
 
-        String payload =
+    public static String translateToEmojis(String message) {
+        String payload = String.format(
             """
             {
                 "model": "mistral-medium",
                 "messages": [
-                    { "role": "user", "content": "Reverse turing test." }
+                    { "role": "system", "content": "Please translate the following message to emojis only. Do not include any comments. End the emoji message with ;" },
+                    { "role": "user", "content": "%s" }
                 ]
             }
-            """;
+            """,
+            message
+        );
 
         HttpRequest request = HttpRequest.newBuilder()
             .uri(URI.create("https://api.mistral.ai/v1/chat/completions"))
@@ -49,10 +52,26 @@ public class MistralDirectAPI {
                 request,
                 HttpResponse.BodyHandlers.ofString()
             );
-            System.out.println("Response Code: " + response.statusCode());
+            String responseBody = response.body();
-            System.out.println("Response Body: " + response.body());
+            return extractContent(responseBody);
         } catch (IOException | InterruptedException e) {
             System.err.println("Error occurred: " + e.getMessage());
+            return message;
         }
     }
+
+    private static String extractContent(String jsonResponse) {
+        // Find the content field in the response
+        int contentIndex = jsonResponse.indexOf("\"content\":\"");
+        if (contentIndex != -1) {
+            int startIndex = contentIndex + "\"content\":\"".length();
+
+            int endIndex = jsonResponse.indexOf(";", startIndex);
+
+            if (endIndex != -1) {
+                return jsonResponse.substring(startIndex, endIndex);
+            }
+        }
+        return "";
+    }
 }

app/src/main/java/clientserver/server/ClientHandler.java

@@ -6,39 +6,51 @@ import java.net.DatagramSocket;
 
 public class ClientHandler implements Runnable {
 
-    private final DatagramSocket socket;
+    private final DatagramSocket clientHandlerSocket;
     private final Client client;
     private boolean running = true;
+    private final MessageProcessor messageProcessor;
 
     public ClientHandler(DatagramSocket socket, Client client) {
-        this.socket = socket;
+        this.clientHandlerSocket = socket;
         this.client = client;
+        this.messageProcessor = new MessageProcessor(
+            client,
+            clientHandlerSocket,
+            this
+        );
+    }
+
+    public Client getClient() {
+        return client;
     }
 
     public void stop() {
         running = false;
-        if (socket != null && !socket.isClosed()) {
+        if (clientHandlerSocket != null && !clientHandlerSocket.isClosed()) {
-            socket.close();
+            clientHandlerSocket.close();
         }
     }
 
+    public static String prettyPrint(Client client) {
+        StringBuilder str = new StringBuilder();
+        str.append(
+            client.getPseudo() +
+            " (" +
+            client.getAddress() +
+            ":" +
+            client.getPort() +
+            ")"
+        );
+        return str.toString();
+    }
+
     @Override
     public void run() {
-        System.out.println(
+        System.out.println("Started handler for client " + prettyPrint(client));
-            "Started handler for client " +
-            client.getAddress() +
-            ":" +
-            client.getPort()
-        );
 
-        // try {
+        while (running && !clientHandlerSocket.isClosed()) {
-        //     socket.setSoTimeout(30000);
+            DatagramPacket packet = Server.receivedPacket(clientHandlerSocket);
-        // } catch (Exception e) {
-        //     System.err.println("Could not set socket timeout");
-        // }
-
-        while (running && !socket.isClosed()) {
-            DatagramPacket packet = Server.receivedPacket(socket);
             if (packet == null) continue;
 
             String message = new String(
@@ -46,29 +58,13 @@ public class ClientHandler implements Runnable {
                 0,
                 packet.getLength()
             );
-            System.out.println(
+            System.out.println(prettyPrint(client) + " : " + message);
-                "Received from " +
+
-                client.getAddress() +
+            messageProcessor.processMessage(message);
-                ":" +
-                client.getPort() +
-                ": " +
-                message
-            );
-            // Reply with echo
-            // String response = "ECHO: " + message;
-            // Server.sendMessage(
-            //     socket,
-            //     response,
-            //     client.getAddress(),
-            //     client.getPort()
-            // );
         }
 
         System.out.println(
-            "Client handler terminated for " +
+            "Client handler terminated for " + prettyPrint(client)
-            client.getAddress() +
-            ":" +
-            client.getPort()
         );
     }
 }

app/src/main/java/clientserver/server/MessageProcessor.java

@@ -0,0 +1,170 @@
+package clientserver.server;
+
+import clientserver.client.Client;
+import clientserver.common.MistralDirectAPI;
+import java.net.DatagramSocket;
+
+public class MessageProcessor {
+
+    private final Client client;
+    private final DatagramSocket clientHandlerSocket;
+    private final ClientHandler clientHandler;
+
+    public MessageProcessor(
+        Client client,
+        DatagramSocket clientHandlerSocket,
+        ClientHandler clientHandler
+    ) {
+        this.client = client;
+        this.clientHandlerSocket = clientHandlerSocket;
+        this.clientHandler = clientHandler;
+    }
+
+    public void processMessage(String message) {
+        if (message == null) {
+            return;
+        }
+
+        if (message.startsWith("/msg ")) {
+            handlePrivateMessage(message);
+            return;
+        }
+
+        switch (message) {
+            case "/list":
+                handleListCommand();
+                break;
+            case "/help":
+                handleHelpCommand();
+                break;
+            case "/msg":
+                handleMsgCommand();
+                break;
+            case "/disconnect":
+                handleDisconnect();
+                break;
+            default:
+                // Broadcast message to all clients
+                broadcastMessageEmoji(message);
+                break;
+        }
+    }
+
+    private void handlePrivateMessage(String message) {
+        String[] parts = message.split(" ", 3);
+        if (parts.length < 3) {
+            handleMsgCommand();
+            return;
+        }
+
+        String targetPseudo = parts[1];
+        String messageContent = parts[2];
+
+        ClientHandler targetHandler = Server.getClientHandler(targetPseudo);
+
+        if (targetHandler == null) {
+            Server.sendMessage(
+                clientHandlerSocket,
+                "> User " + targetPseudo + " not found",
+                client.getAddress(),
+                client.getPort()
+            );
+            return;
+        }
+
+        // Send private message to target
+        Client targetClient = targetHandler.getClient();
+        Server.sendMessage(
+            clientHandlerSocket,
+            "> " +
+            client.getPseudo() +
+            " -> " +
+            targetClient.getPseudo() +
+            ": " +
+            messageContent,
+            targetClient.getAddress(),
+            targetClient.getPort()
+        );
+
+        // Send confirmation to sender
+        Server.sendMessage(
+            clientHandlerSocket,
+            "> " +
+            client.getPseudo() +
+            " -> " +
+            targetClient.getPseudo() +
+            ": " +
+            messageContent,
+            client.getAddress(),
+            client.getPort()
+        );
+    }
+
+    private void broadcastMessage(String message) {
+        String formattedMessage = "> " + client.getPseudo() + ": " + message;
+
+        for (ClientHandler handler : Server.getAllClientHandlers()) {
+            Client targetClient = handler.getClient();
+            Server.sendMessage(
+                clientHandlerSocket,
+                formattedMessage,
+                targetClient.getAddress(),
+                targetClient.getPort()
+            );
+        }
+    }
+
+    private void broadcastMessageEmoji(String message) {
+        // Translate message to emojis
+        String emojiMessage = MistralDirectAPI.translateToEmojis(message);
+        String formattedMessage =
+            "> " + client.getPseudo() + ": " + emojiMessage;
+
+        for (ClientHandler handler : Server.getAllClientHandlers()) {
+            Client targetClient = handler.getClient();
+            Server.sendMessage(
+                clientHandlerSocket,
+                formattedMessage,
+                targetClient.getAddress(),
+                targetClient.getPort()
+            );
+        }
+    }
+
+    private void handleMsgCommand() {
+        Server.sendMessage(
+            clientHandlerSocket,
+            "> /msg <target> <message> : send a message to a client",
+            client.getAddress(),
+            client.getPort()
+        );
+    }
+
+    private void handleListCommand() {
+        Server.sendMessage(
+            clientHandlerSocket,
+            Server.getPseudos(),
+            client.getAddress(),
+            client.getPort()
+        );
+    }
+
+    private void handleHelpCommand() {
+        Server.sendMessage(
+            clientHandlerSocket,
+            "> /list : list all connected clients" +
+            "\n> /msg <target> <message> : send a message to a client" +
+            "\n> /disconnect : disconnect from the server",
+            client.getAddress(),
+            client.getPort()
+        );
+    }
+
+    private void handleDisconnect() {
+        System.out.println(
+            "Client deconnection : " + ClientHandler.prettyPrint(client)
+        );
+        Server.removeClientHandler(client.getPseudo());
+        clientHandler.stop();
+    }
+}

app/src/main/java/clientserver/server/Server.java

@@ -4,12 +4,20 @@ import clientserver.client.Client;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class Server {
 
     private int mainServerPort;
     private DatagramSocket mainServerSocket;
     private boolean isRunning;
+    private static Map<
+        String,
+        ClientHandler
+    > mapPseudosConnectedClientsHandlers = new ConcurrentHashMap<>();
 
     public Server(int port) {
         this.mainServerPort = port;
@@ -53,6 +61,10 @@ public class Server {
         }
     }
 
+    public static String packetToMessage(DatagramPacket packet) {
+        return new String(packet.getData(), 0, packet.getLength());
+    }
+
     public static void sendMessage(
         DatagramSocket socket,
         String message,
@@ -80,47 +92,56 @@ public class Server {
         DatagramPacket packet = receivedPacket(mainServerSocket);
         if (packet == null) return;
 
-        Client client = new Client(packet.getAddress(), packet.getPort());
+        int originalClientPort = packet.getPort();
-
+        InetAddress clientAddress = packet.getAddress();
         // Log the initial connection request
         System.out.println(
             "New connection request from " +
-            client.getAddress() +
+            clientAddress +
             ":" +
-            client.getPort()
+            originalClientPort
         );
 
         // Process the received message
-        String message = new String(packet.getData(), 0, packet.getLength());
+        String pseudoMessage = new String(
-        System.out.println(
+            packet.getData(),
-            "Received message from " +
+            0,
-            client.getAddress() +
+            packet.getLength()
-            ":" +
-            client.getPort() +
-            ": " +
-            message
         );
 
+        System.out.println(
+            "Received message from " +
+            clientAddress +
+            ":" +
+            originalClientPort +
+            ": " +
+            pseudoMessage
+        );
         // Create a new socket for this client
-        DatagramSocket clientSocket = createNewSocket();
+        DatagramSocket clientHandlerSocket = createNewSocket();
-        if (clientSocket == null) return;
 
-        int newPort = clientSocket.getLocalPort();
+        if (clientHandlerSocket == null) return;
-        client.setPort(newPort);
+        int clientHandlerLocalPort = clientHandlerSocket.getLocalPort();
 
+        Client client = new Client(clientAddress, originalClientPort);
+
+        client.setPseudo(pseudoMessage);
         // Send new port information to client
-        String response = "PORT:" + newPort;
+        String response = "PORT:" + clientHandlerLocalPort;
+
         sendMessage(
             mainServerSocket,
             response,
-            client.getAddress(),
+            clientAddress,
             packet.getPort()
         );
-
         // Create and start a ClientHandler for this connection
-        ClientHandler handler = new ClientHandler(clientSocket, client);
+        ClientHandler handler = new ClientHandler(clientHandlerSocket, client);
+
         Thread thread = new Thread(handler);
         thread.start();
+        // Add client handler to mapPseudosConnectedClients
+        addConnectedClientHandler(pseudoMessage, handler);
     }
 
     public void run() {
@@ -137,4 +158,40 @@ public class Server {
         }
         System.out.println("Server shutdown");
     }
+
+    public static String getPseudos() {
+        StringBuilder pseudos = new StringBuilder();
+        int size = mapPseudosConnectedClientsHandlers.size();
+        int count = 0;
+        for (Map.Entry<
+            String,
+            ClientHandler
+        > entry : mapPseudosConnectedClientsHandlers.entrySet()) {
+            count++;
+            pseudos.append("> ").append(entry.getKey());
+            if (count < size) {
+                pseudos.append("\n");
+            }
+        }
+        return pseudos.toString();
+    }
+
+    public static ClientHandler getClientHandler(String pseudo) {
+        return mapPseudosConnectedClientsHandlers.get(pseudo);
+    }
+
+    public static Collection<ClientHandler> getAllClientHandlers() {
+        return mapPseudosConnectedClientsHandlers.values();
+    }
+
+    public void addConnectedClientHandler(
+        String pseudo,
+        ClientHandler clientHandler
+    ) {
+        mapPseudosConnectedClientsHandlers.putIfAbsent(pseudo, clientHandler);
+    }
+
+    public static void removeClientHandler(String pseudo) {
+        mapPseudosConnectedClientsHandlers.remove(pseudo);
+    }
 }

gradle.properties

@@ -0,0 +1 @@
+org.gradle.console=plain