old files

main/src/main/java/client/Client.java

@@ -0,0 +1,147 @@
+package client;
+
+import java.util.Scanner;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import client.structs.NetworkManager;
+import client.handlers.UnicastHandler;
+import client.handlers.MulticastHandler;
+import client.handlers.BroadcastHandler;
+import client.utils.InputCommandRouter;
+import shared.enums.ConnType;
+
+/**
+ * Client application that manages network communications and thread handling.
+ * Created by: 0x1eo
+ * Last modified: 2024-12-12
+ */
+public class Client implements AutoCloseable {
+    private static final Logger LOGGER = Logger.getLogger(Client.class.getName());
+
+    public static final String SERVER_ADDRESS = "localhost";
+    public static final String BROADCAST_ADDRESS = "255.255.255.255";
+    public static final int SERVER_PORT = 7500;
+    public static int CLIENT_PORT = 7501;  // Made non-final to allow dynamic assignment
+    public static final int MULTICAST_PORT = 7502;
+    public static final int BUFFER_SIZE = 1024;
+
+    private final ExecutorService executorService;
+    private final NetworkManager networkManager;
+    private static Client instance;
+
+    private Client() {
+        this.executorService = Executors.newFixedThreadPool(3);
+        this.networkManager = NetworkManager.getInstance();
+    }
+
+    public static synchronized Client getInstance() {
+        if (instance == null) {
+            instance = new Client();
+        }
+        return instance;
+    }
+
+    /**
+     * Initializes and starts the client application.
+     */
+    public void start() {
+        LOGGER.info("Initializing client application...");
+        try {
+            networkManager.initializePrimaryConnection();
+            setupShutdownHook();
+            initializeAuthenticatedState();
+            startInputLoop();
+            LOGGER.info("Client initialization completed successfully");
+        } catch (Exception e) {
+            LOGGER.severe("Failed to initialize client: " + e.getMessage());
+            close();
+        }
+    }
+
+    /**
+     * Initializes authenticated state and starts network handlers.
+     */
+    public void initializeAuthenticatedState() {
+        try {
+            NetworkManager networkManager = NetworkManager.getInstance();
+            networkManager.initializeAuthenticatedConnections();
+
+            if (networkManager.isAuthenticated()) {
+                startNetworkHandlers();
+                LOGGER.info("Authenticated state initialized successfully on port " + CLIENT_PORT);
+            } else {
+                LOGGER.severe("Authentication failed");
+                close();
+            }
+        } catch (NetworkManager.NetworkInitializationException e) {
+            LOGGER.log(Level.SEVERE, "Failed to initialize authenticated state", e);
+            close();
+        }
+    }
+
+    private void startNetworkHandlers() {
+        executorService.execute(new UnicastHandler());
+        executorService.execute(new MulticastHandler());
+        executorService.execute(new BroadcastHandler());
+    }
+
+    private void setupShutdownHook() {
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            LOGGER.info("Shutdown hook triggered");
+            close();
+        }));
+    }
+
+    @Override
+    public void close() {
+        LOGGER.info("Initiating client shutdown sequence...");
+        shutdownExecutors();
+        networkManager.close();
+        LOGGER.info("Client shutdown completed");
+        System.exit(0);
+    }
+
+    private void shutdownExecutors() {
+        try {
+            UnicastHandler.getExecutorService().shutdown();
+            executorService.shutdown();
+
+            // Wait for termination
+            if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
+                executorService.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            LOGGER.warning("Executor service shutdown interrupted: " + e.getMessage());
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+            LOGGER.severe("Error during executor service shutdown: " + e.getMessage());
+        }
+    }
+
+    private void startInputLoop() {
+        Thread inputThread = new Thread(() -> {
+            try (Scanner scanner = new Scanner(System.in)) {
+                while (!Thread.currentThread().isInterrupted()) {
+                    String input = scanner.nextLine();
+                    String response = InputCommandRouter.processInput(ConnType.UNICAST, input);
+                    if (response != null) {
+                        networkManager.getUnicastOut().println(response);
+                    }
+                }
+            } catch (Exception e) {
+                LOGGER.log(Level.SEVERE, "Error in input loop", e);
+            }
+        });
+        inputThread.setName("InputProcessor");
+        inputThread.start();
+    }
+
+    public static void main(String[] args) {
+        Client client = Client.getInstance();
+        client.start();
+    }
+}

main/src/main/java/client/handlers/BroadcastHandler.java

@@ -0,0 +1,164 @@
+package client.handlers;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import client.Client;
+import client.structs.NetworkManager;
+import client.utils.InputCommandRouter;
+import shared.enums.ConnType;
+
+/**
+ * Handles broadcast communication across the network.
+ * Receives and processes broadcast packets, excluding packets from the local host.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ */
+public class BroadcastHandler implements Runnable, AutoCloseable {
+    private static final Logger LOGGER = Logger.getLogger(BroadcastHandler.class.getName());
+    private static final int SOCKET_TIMEOUT_MS = 5000; // 5 seconds
+    private static final long TIMEOUT_LOG_INTERVAL = 300000; // Log timeouts every 5 minutes
+    private static final long HEARTBEAT_INTERVAL = 60000; // 1 minute
+
+    private final NetworkManager networkManager;
+    private volatile boolean isRunning;
+    private DatagramSocket socket;
+    private long lastTimeoutLog;
+    private long lastHeartbeat;
+
+    public BroadcastHandler() {
+        this.networkManager = NetworkManager.getInstance();
+        this.isRunning = true;
+        this.lastTimeoutLog = System.currentTimeMillis();
+        this.lastHeartbeat = System.currentTimeMillis();
+    }
+
+    @Override
+    public void run() {
+        try {
+            initializeSocket();
+            LOGGER.info("Broadcast handler started successfully on port " + socket.getLocalPort());
+            processBroadcastMessages();
+        } catch (IOException e) {
+            if (isRunning) {
+                LOGGER.log(Level.SEVERE, "Fatal error in broadcast handler", e);
+            }
+        } finally {
+            close();
+        }
+    }
+
+    private void initializeSocket() throws IOException {
+        this.socket = networkManager.getBroadcastSocket();
+        if (socket == null) {
+            throw new IOException("Failed to initialize broadcast socket");
+        }
+        socket.setSoTimeout(SOCKET_TIMEOUT_MS);
+        LOGGER.fine("Broadcast socket timeout set to " + SOCKET_TIMEOUT_MS + "ms");
+    }
+
+    private void processBroadcastMessages() throws IOException {
+        byte[] buffer = new byte[Client.BUFFER_SIZE];
+        InetAddress localhost = InetAddress.getLocalHost();
+
+        while (isRunning) {
+            checkHeartbeat();
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+
+            try {
+                receiveAndProcessPacket(packet, localhost);
+            } catch (IOException e) {
+                handleReceiveException(e);
+            }
+        }
+    }
+
+    private void handleReceiveException(IOException e) {
+        if (!isRunning) return;
+
+        if (e instanceof java.net.SocketTimeoutException) {
+            long currentTime = System.currentTimeMillis();
+            if (currentTime - lastTimeoutLog > TIMEOUT_LOG_INTERVAL) {
+                LOGGER.fine("No broadcast messages received in the last " +
+                        (SOCKET_TIMEOUT_MS / 1000) + " seconds");
+                lastTimeoutLog = currentTime;
+            }
+        } else {
+            LOGGER.log(Level.WARNING, "Error receiving broadcast packet", e);
+        }
+    }
+
+    private void checkHeartbeat() {
+        long currentTime = System.currentTimeMillis();
+        if (currentTime - lastHeartbeat > HEARTBEAT_INTERVAL) {
+            if (socket != null && !socket.isClosed()) {
+                LOGGER.fine("Broadcast connection alive - listening for messages");
+            }
+            lastHeartbeat = currentTime;
+        }
+    }
+
+    private void receiveAndProcessPacket(DatagramPacket packet, InetAddress localhost) throws IOException {
+        socket.receive(packet);
+
+        if (packet.getAddress().equals(localhost)) {
+            return; // Skip localhost packets
+        }
+
+        String input = extractMessage(packet);
+        String output = processMessage(input);
+
+        if (output != null) {
+            sendResponse(output, packet.getAddress(), packet.getPort());
+        }
+    }
+
+    private String extractMessage(DatagramPacket packet) {
+        return new String(
+                packet.getData(),
+                0,
+                packet.getLength(),
+                StandardCharsets.UTF_8
+        ).trim();
+    }
+
+    private String processMessage(String input) {
+        try {
+            return InputCommandRouter.processInput(ConnType.BROADCAST, input);
+        } catch (Exception e) {
+            LOGGER.log(Level.WARNING, "Error processing message", e);
+            return null;
+        }
+    }
+
+
+    private void sendResponse(String message, InetAddress address, int port) {
+        try {
+            byte[] responseData = message.getBytes(StandardCharsets.UTF_8);
+            DatagramPacket response = new DatagramPacket(
+                    responseData,
+                    responseData.length,
+                    address,
+                    port
+            );
+            socket.send(response);
+        } catch (IOException e) {
+            LOGGER.log(Level.WARNING, "Failed to send broadcast response", e);
+        }
+    }
+
+    @Override
+    public void close() {
+        isRunning = false;
+        if (socket != null && !socket.isClosed()) {
+            socket.close();
+            LOGGER.info("Broadcast handler closed");
+        }
+    }
+}

main/src/main/java/client/handlers/MulticastHandler.java

@@ -0,0 +1,163 @@
+package client.handlers;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import client.Client;
+import client.structs.NetworkManager;
+import client.utils.InputCommandRouter;
+import shared.enums.ConnType;
+
+/**
+ * Handles multicast communication between network nodes.
+ * Receives and processes multicast packets, excluding packets from the local host.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ */
+public class MulticastHandler implements Runnable, AutoCloseable {
+    private static final Logger LOGGER = Logger.getLogger(MulticastHandler.class.getName());
+    private static final int SOCKET_TIMEOUT_MS = 5000; // 5 seconds
+    private static final long TIMEOUT_LOG_INTERVAL = 300000; // Log timeouts every 5 minutes
+    private static final long HEARTBEAT_INTERVAL = 60000; // 1 minute
+
+    private final NetworkManager networkManager;
+    private volatile boolean isRunning;
+    private DatagramSocket socket;
+    private long lastTimeoutLog;
+    private long lastHeartbeat;
+
+    public MulticastHandler() {
+        this.networkManager = NetworkManager.getInstance();
+        this.isRunning = true;
+        this.lastTimeoutLog = System.currentTimeMillis();
+        this.lastHeartbeat = System.currentTimeMillis();
+    }
+
+    @Override
+    public void run() {
+        try {
+            initializeSocket();
+            LOGGER.info("Multicast handler started successfully on port " + socket.getLocalPort());
+            processMulticastMessages();
+        } catch (IOException e) {
+            if (isRunning) {
+                LOGGER.log(Level.SEVERE, "Fatal error in multicast handler", e);
+            }
+        } finally {
+            close();
+        }
+    }
+
+    private void initializeSocket() throws IOException {
+        this.socket = networkManager.getMulticastSocket();
+        if (socket == null) {
+            throw new IOException("Failed to initialize multicast socket");
+        }
+        socket.setSoTimeout(SOCKET_TIMEOUT_MS);
+        LOGGER.fine("Multicast socket timeout set to " + SOCKET_TIMEOUT_MS + "ms");
+    }
+
+    private void processMulticastMessages() throws IOException {
+        byte[] buffer = new byte[Client.BUFFER_SIZE];
+        InetAddress localhost = InetAddress.getLocalHost();
+
+        while (isRunning) {
+            checkHeartbeat();
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+
+            try {
+                receiveAndProcessPacket(packet, localhost);
+            } catch (IOException e) {
+                handleReceiveException(e);
+            }
+        }
+    }
+
+    private void handleReceiveException(IOException e) {
+        if (!isRunning) return;
+
+        if (e instanceof java.net.SocketTimeoutException) {
+            long currentTime = System.currentTimeMillis();
+            if (currentTime - lastTimeoutLog > TIMEOUT_LOG_INTERVAL) {
+                LOGGER.fine("No multicast messages received in the last " +
+                        (SOCKET_TIMEOUT_MS / 1000) + " seconds");
+                lastTimeoutLog = currentTime;
+            }
+        } else {
+            LOGGER.log(Level.WARNING, "Error receiving multicast packet", e);
+        }
+    }
+
+    private void checkHeartbeat() {
+        long currentTime = System.currentTimeMillis();
+        if (currentTime - lastHeartbeat > HEARTBEAT_INTERVAL) {
+            if (socket != null && !socket.isClosed()) {
+                LOGGER.fine("Multicast connection alive - listening for messages");
+            }
+            lastHeartbeat = currentTime;
+        }
+    }
+
+    private void receiveAndProcessPacket(DatagramPacket packet, InetAddress localhost) throws IOException {
+        socket.receive(packet);
+
+        if (packet.getAddress().equals(localhost)) {
+            return; // Skip localhost packets
+        }
+
+        String input = extractMessage(packet);
+        String output = processMessage(input);
+
+        if (output != null) {
+            sendResponse(output, packet.getAddress(), packet.getPort());
+        }
+    }
+
+    private String extractMessage(DatagramPacket packet) {
+        return new String(
+                packet.getData(),
+                0,
+                packet.getLength(),
+                StandardCharsets.UTF_8
+        ).trim();
+    }
+
+    private String processMessage(String input) {
+        try {
+            return InputCommandRouter.processInput(ConnType.MULTICAST, input);
+        } catch (Exception e) {
+            LOGGER.log(Level.WARNING, "Error processing message", e);
+            return null;
+        }
+    }
+
+    private void sendResponse(String message, InetAddress address, int port) {
+        try {
+            byte[] responseData = message.getBytes(StandardCharsets.UTF_8);
+            DatagramPacket response = new DatagramPacket(
+                    responseData,
+                    responseData.length,
+                    address,
+                    port
+            );
+            socket.send(response);
+        } catch (IOException e) {
+            LOGGER.log(Level.WARNING, "Failed to send multicast response", e);
+        }
+    }
+
+    @Override
+    public void close() {
+        isRunning = false;
+        if (socket != null && !socket.isClosed()) {
+            socket.close();
+            LOGGER.info("Multicast handler closed");
+        }
+    }
+}

main/src/main/java/client/handlers/UnicastHandler.java

@@ -0,0 +1,143 @@
+package client.handlers;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import client.structs.NetworkManager;
+import client.utils.InputCommandRouter;
+import shared.enums.ConnType;
+
+/**
+ * Handles unicast (point-to-point) connections between clients.
+ * Manages incoming connections and processes their messages in separate threads.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public class UnicastHandler implements Runnable, AutoCloseable {
+    private static final Logger LOGGER = Logger.getLogger(UnicastHandler.class.getName());
+    private static final int MAX_THREADS = 50;
+    private static final int SOCKET_TIMEOUT_MS = 30000; // 30 seconds
+    private static final int SHUTDOWN_TIMEOUT_SECONDS = 5;
+
+    private static ExecutorService connectionPool = null;
+    private final NetworkManager networkManager;
+    private volatile boolean isRunning;
+
+    /**
+     * Creates a new UnicastHandler with a fixed thread pool.
+     */
+    public UnicastHandler() {
+        connectionPool = Executors.newFixedThreadPool(MAX_THREADS);
+        this.networkManager = NetworkManager.getInstance();
+        this.isRunning = true;
+    }
+
+    @Override
+    public void run() {
+        ServerSocket serverSocket = networkManager.getServerSocket();
+        if (serverSocket == null) {
+            LOGGER.severe("Server socket is null. Cannot start UnicastHandler.");
+            return;
+        }
+
+        while (isRunning) {
+            try {
+                Socket clientSocket = serverSocket.accept();
+                configureSocket(clientSocket);
+                connectionPool.execute(new ClientHandler(clientSocket));
+            } catch (IOException e) {
+                if (isRunning) {
+                    LOGGER.log(Level.SEVERE, "Error accepting connection", e);
+                }
+            }
+        }
+    }
+
+    private void configureSocket(Socket socket) throws IOException {
+        socket.setSoTimeout(SOCKET_TIMEOUT_MS);
+        socket.setKeepAlive(true);
+    }
+
+    @Override
+    public void close() {
+        isRunning = false;
+        shutdownConnectionPool();
+    }
+
+    private void shutdownConnectionPool() {
+        connectionPool.shutdown();
+        try {
+            if (!connectionPool.awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+                connectionPool.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            connectionPool.shutdownNow();
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    /**
+     * Gets the executor service managing client connections.
+     *
+     * @return the executor service
+     */
+    public static ExecutorService getExecutorService() {
+        return connectionPool;
+    }
+
+    /**
+     * Handles individual client connections in separate threads.
+     */
+    private static class ClientHandler implements Runnable {
+        private final Socket clientSocket;
+        private final String clientInfo;
+
+        public ClientHandler(Socket socket) {
+            this.clientSocket = socket;
+            this.clientInfo = String.format("%s:%d",
+                    socket.getInetAddress().getHostAddress(),
+                    socket.getPort());
+        }
+
+        @Override
+        public void run() {
+            LOGGER.info(() -> "New connection established with " + clientInfo);
+
+            try (Socket socket = clientSocket;
+                 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+                 PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
+
+                handleClientCommunication(in, out);
+
+            } catch (IOException e) {
+                LOGGER.log(Level.SEVERE, "Error handling client " + clientInfo, e);
+            } finally {
+                LOGGER.info(() -> "Connection closed with " + clientInfo);
+            }
+        }
+
+        private void handleClientCommunication(BufferedReader in, PrintWriter out) throws IOException {
+            String input;
+            while ((input = in.readLine()) != null) {
+                try {
+                    String response = InputCommandRouter.processInput(ConnType.UNICAST, input);
+                    if (response != null) {
+                        out.println(response);
+                    }
+                } catch (Exception e) {
+                    LOGGER.log(Level.WARNING, "Error processing message from " + clientInfo, e);
+                }
+            }
+        }
+    }
+}

main/src/main/java/client/structs/NetworkManager.java

@@ -0,0 +1,222 @@
+package client.structs;
+
+import java.io.*;
+import java.net.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import client.Client;
+
+/**
+ * Network connection manager for the emergency communication client.
+ * Implements thread-safe singleton pattern and manages all network resources.
+ *
+ * Features:
+ * - Connection retry mechanism
+ * - Multiple communication channels (Unicast, Multicast, Broadcast)
+ * - Automatic resource cleanup
+ * - Connection state monitoring
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ */
+public class NetworkManager implements AutoCloseable {
+    private static final Logger LOGGER = Logger.getLogger(NetworkManager.class.getName());
+    private static volatile NetworkManager instance;
+    private static final Object LOCK = new Object();
+
+    private static final int MAX_CONNECTION_RETRIES = 3;
+    private static final int RETRY_DELAY_MS = 2000;
+    private static final int SOCKET_TIMEOUT_MS = 5000;
+
+    private final AtomicBoolean isAuthenticated = new AtomicBoolean(false);
+    private volatile String username;
+    private final SocketContainer sockets;
+
+    private static final int PORT_RANGE_START = 7501;
+    private static final int PORT_RANGE_END = 7600;
+    private static final int MAX_PORT_ATTEMPTS = 10;
+
+    private NetworkManager() {
+        this.sockets = new SocketContainer();
+    }
+
+    public static NetworkManager getInstance() {
+        NetworkManager result = instance;
+        if (result == null) {
+            synchronized (LOCK) {
+                result = instance;
+                if (result == null) {
+                    instance = result = new NetworkManager();
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Initializes primary connection with retry mechanism.
+     *
+     * @throws NetworkInitializationException if connection fails after retries
+     */
+    public void initializePrimaryConnection() {
+        for (int attempt = 1; attempt <= MAX_CONNECTION_RETRIES; attempt++) {
+            try {
+                establishPrimaryConnection();
+                LOGGER.info("Primary connection initialized successfully on attempt " + attempt);
+                return;
+            } catch (IOException e) {
+                handleConnectionRetry(attempt, e);
+            }
+        }
+        throw new NetworkInitializationException("Failed to initialize after " + MAX_CONNECTION_RETRIES + " attempts", null);
+    }
+
+    private void establishPrimaryConnection() throws IOException {
+        Socket unicastSocket = new Socket(Client.SERVER_ADDRESS, Client.SERVER_PORT);
+        unicastSocket.setSoTimeout(SOCKET_TIMEOUT_MS);
+
+        sockets.unicastSocket = unicastSocket;
+        sockets.unicastIn = new BufferedReader(
+                new InputStreamReader(unicastSocket.getInputStream())
+        );
+        sockets.unicastOut = new PrintWriter(
+                unicastSocket.getOutputStream(),
+                true
+        );
+    }
+
+    private void handleConnectionRetry(int attempt, IOException e) {
+        LOGGER.log(Level.WARNING,
+                String.format("Connection attempt %d/%d failed", attempt, MAX_CONNECTION_RETRIES),
+                e
+        );
+
+        if (attempt < MAX_CONNECTION_RETRIES) {
+            try {
+                Thread.sleep(RETRY_DELAY_MS);
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+                throw new NetworkInitializationException("Connection retry interrupted", ie);
+            }
+        }
+    }
+
+    /**
+     * Initializes authenticated connections for multicast and broadcast.
+     *
+     * @throws NetworkInitializationException if initialization fails
+     */
+    public void initializeAuthenticatedConnections() {
+        for (int port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
+            try {
+                setupAuthenticatedSockets(port);
+                isAuthenticated.set(true);
+                LOGGER.info(String.format(
+                        "Authenticated connections initialized for user %s on port %d",
+                        username, port
+                ));
+                return;
+            } catch (IOException e) {
+                if (port >= PORT_RANGE_END) {
+                    isAuthenticated.set(false);
+                    throw new NetworkInitializationException(
+                            "Failed to find available ports in range " +
+                                    PORT_RANGE_START + "-" + PORT_RANGE_END,
+                            e
+                    );
+                }
+                LOGGER.warning(String.format(
+                        "Port %d in use, trying next port", port
+                ));
+            }
+        }
+    }
+
+    private void setupAuthenticatedSockets(int basePort) throws IOException {
+        // Server socket uses the base port
+        sockets.serverSocket = new ServerSocket(basePort);
+
+        // Multicast socket uses the multicast port
+        sockets.multicastSocket = new MulticastSocket(Client.MULTICAST_PORT);
+
+        // Broadcast socket uses base port + 1 to avoid conflict
+        sockets.broadcastSocket = createBroadcastSocket(basePort + 1);
+
+        // Update the client port in the Client class
+        Client.CLIENT_PORT = basePort;
+    }
+
+    private DatagramSocket createBroadcastSocket(int port) throws IOException {
+        DatagramSocket socket = new DatagramSocket(
+                port,
+                InetAddress.getByName(Client.BROADCAST_ADDRESS)
+        );
+        socket.setBroadcast(true);
+        return socket;
+    }
+
+    @Override
+    public void close() {
+        sockets.closeAll();
+        isAuthenticated.set(false);
+        LOGGER.info("Network manager closed successfully");
+    }
+
+    // Thread-safe getters
+    public boolean isAuthenticated() { return isAuthenticated.get(); }
+    public String getUsername() { return username; }
+    public Socket getUnicastSocket() { return sockets.unicastSocket; }
+    public BufferedReader getUnicastIn() { return sockets.unicastIn; }
+    public PrintWriter getUnicastOut() { return sockets.unicastOut; }
+    public ServerSocket getServerSocket() { return sockets.serverSocket; }
+    public MulticastSocket getMulticastSocket() { return sockets.multicastSocket; }
+    public DatagramSocket getBroadcastSocket() { return sockets.broadcastSocket; }
+
+    // Thread-safe setter
+    public void setUsername(String username) {
+        this.username = username;
+        LOGGER.info("Username set to: " + username);
+    }
+
+    /**
+     * Thread-safe container for network resources.
+     */
+    private static class SocketContainer {
+        private volatile Socket unicastSocket;
+        private volatile BufferedReader unicastIn;
+        private volatile PrintWriter unicastOut;
+        private volatile ServerSocket serverSocket;
+        private volatile MulticastSocket multicastSocket;
+        private volatile DatagramSocket broadcastSocket;
+
+        private void closeAll() {
+            closeQuietly(broadcastSocket, "BroadcastSocket");
+            closeQuietly(multicastSocket, "MulticastSocket");
+            closeQuietly(serverSocket, "ServerSocket");
+            closeQuietly(unicastSocket, "UnicastSocket");
+            closeQuietly(unicastOut, "UnicastWriter");
+            closeQuietly(unicastIn, "UnicastReader");
+        }
+
+        private void closeQuietly(AutoCloseable resource, String resourceName) {
+            if (resource != null) {
+                try {
+                    resource.close();
+                    LOGGER.fine(resourceName + " closed successfully");
+                } catch (Exception e) {
+                    LOGGER.warning(resourceName + " close failed: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * Custom exception for network initialization failures.
+     */
+    public static class NetworkInitializationException extends RuntimeException {
+        public NetworkInitializationException(String message, Throwable cause) {
+            super(message, cause);
+        }
+    }
+}

main/src/main/java/client/structs/TerminalMessageHandler.java

@@ -0,0 +1,18 @@
+package client.structs;
+
+public class TerminalMessageHandler {
+    public static void displayMessage(String from, String to, String content, String date) {
+        System.out.printf("[%s] %s -> %s: %s%n", date, from, to, content);
+    }
+
+    public static void displayRequest(String from, String to, String content, String date, String accepter) {
+        String accepterStatus = accepter.isEmpty() ? "PENDING" : "ACCEPTED by " + accepter;
+        System.out.printf("[%s] REQUEST from %s to %s: %s (%s)%n", date, from, to, content, accepterStatus);
+    }
+
+    public static boolean promptRequestAcceptance(String from, String to, String content) {
+        System.out.printf("Accept request from %s to %s: %s%n", from, to, content);
+        System.out.print("Accept? (y/n): ");
+        return System.console().readLine().trim().toLowerCase().startsWith("y");
+    }
+}

main/src/main/java/client/utils/ChatMessageHandler.java

@@ -0,0 +1,162 @@
+package client.utils;
+
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.logging.Logger;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import client.structs.NetworkManager;
+import client.structs.TerminalMessageHandler;
+
+/**
+ * Handles chat message operations including creation, receiving, and processing of messages and requests.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public class ChatMessageHandler {
+    private static final Logger LOGGER = Logger.getLogger(ChatMessageHandler.class.getName());
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm");
+    private static final NetworkManager networkManager = NetworkManager.getInstance();
+
+    private ChatMessageHandler() {} // Prevent instantiation
+
+    /**
+     * Message types supported by the chat system.
+     */
+    public enum MessageType {
+        MESSAGE("message"),
+        REQUEST("request"),
+        JOIN_GROUP("joinGroup");
+
+        private final String command;
+
+        MessageType(String command) {
+            this.command = command;
+        }
+
+        public String getCommand() {
+            return command;
+        }
+    }
+
+    /**
+     * Creates a basic message structure with common fields.
+     */
+    private static JSONObject createBaseMessage(MessageType type, String destination, String content) {
+        JSONObject json = new JSONObject();
+        json.put("command", type.getCommand());
+        json.put("from", networkManager.getUsername());
+        json.put("to", destination);
+        json.put("content", content);
+        json.put("date", LocalDateTime.now().format(DATE_FORMATTER));
+        return json;
+    }
+
+    public static JSONObject createMessage(String destination, String content) {
+        return createBaseMessage(MessageType.MESSAGE, destination, content);
+    }
+
+    public static JSONObject createRequest(String destination, String content) {
+        JSONObject json = createBaseMessage(MessageType.REQUEST, destination, content);
+        json.put("accepter", "");
+        return json;
+    }
+
+    /**
+     * Validates if a JSON object contains all required fields.
+     */
+    private static boolean validateMessageFields(JSONObject json, String... requiredFields) {
+        for (String field : requiredFields) {
+            if (!json.has(field)) {
+                LOGGER.warning("Missing required field: " + field);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void receiveMessage(JSONObject json) {
+        if (!validateMessageFields(json, "from", "to", "content", "date")) {
+            return;
+        }
+
+        TerminalMessageHandler.displayMessage(
+                json.getString("from"),
+                json.getString("to"),
+                json.getString("content"),
+                json.getString("date")
+        );
+    }
+
+    public static void receiveRequest(JSONObject json) {
+        if (!validateMessageFields(json, "from", "to", "content", "date", "accepter")) {
+            return;
+        }
+
+        TerminalMessageHandler.displayRequest(
+                json.getString("from"),
+                json.getString("to"),
+                json.getString("content"),
+                json.getString("date"),
+                json.getString("accepter")
+        );
+    }
+
+    public static String handleAnswerRequest(JSONObject json) {
+        if (!validateMessageFields(json, "from", "to", "content")) {
+            return null;
+        }
+
+        boolean accepted = TerminalMessageHandler.promptRequestAcceptance(
+                json.getString("from"),
+                json.getString("to"),
+                json.getString("content")
+        );
+
+        return new JSONObject().put("response", accepted ? "YES" : "NO").toString();
+    }
+
+    public static void processEvents(JSONObject json) {
+        if (!json.has("events")) {
+            LOGGER.warning("No events field in JSON");
+            return;
+        }
+
+        JSONArray events = json.getJSONArray("events");
+        events.forEach(event -> {
+            JSONObject eventObj = (JSONObject) event;
+            if (!eventObj.has("command")) {
+                LOGGER.warning("Event missing command field");
+                return;
+            }
+
+            String command = eventObj.getString("command");
+            try {
+                switch (MessageType.valueOf(command.toUpperCase())) {
+                    case MESSAGE -> receiveMessage(eventObj);
+                    case REQUEST -> receiveRequest(eventObj);
+                    default -> LOGGER.warning("Unknown command: " + command);
+                }
+            } catch (IllegalArgumentException e) {
+                LOGGER.warning("Invalid command type: " + command);
+            }
+        });
+    }
+
+    public static void announceJoinGroup(String ip) {
+        try {
+            JSONObject json = new JSONObject()
+                    .put("command", MessageType.JOIN_GROUP.getCommand())
+                    .put("group", ip)
+                    .put("username", networkManager.getUsername());
+
+            networkManager.getUnicastOut().println(json);
+        } catch (JSONException e) {
+            LOGGER.severe("Failed to announce group join: " + e.getMessage());
+        }
+    }
+}

main/src/main/java/client/utils/InputCommandRouter.java

@@ -0,0 +1,157 @@
+package client.utils;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.json.JSONObject;
+import shared.enums.ConnType;
+import client.structs.NetworkManager;
+import shared.enums.Hierarchy;
+
+/**
+ * Client-side command router that processes and formats commands according to server protocol.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13 16:41:03
+ */
+public class InputCommandRouter {
+    private static final Logger LOGGER = Logger.getLogger(InputCommandRouter.class.getName());
+    private static final NetworkManager networkManager = NetworkManager.getInstance();
+
+    /**
+     * Processes input and formats it according to server protocol.
+     *
+     * @param connType The type of connection (UNICAST, MULTICAST, BROADCAST)
+     * @param input The user's input string
+     * @return Formatted JSON string or null if no response needed
+     */
+    public static String processInput(ConnType connType, String input) {
+        if (input == null || input.trim().isEmpty()) {
+            return null;
+        }
+
+        String trimmedInput = input.trim();
+
+        // Handle client-side commands
+        if (trimmedInput.startsWith("{command:")) {
+            return handleCommand(connType, trimmedInput);
+        }
+
+        // Handle messages and requests
+        return handleMessage(connType, trimmedInput);
+    }
+
+    private static String handleCommand(ConnType connType, String command) {
+        if (connType != ConnType.UNICAST) {
+            return null;
+        }
+
+        // Split by : but keep quotes intact
+        String[] parts = command.substring(9, command.length() - 1).split(":");
+        String cmd = parts[0].toLowerCase();
+
+        switch (cmd) {
+            case "help":
+                displayHelp();
+                return null;
+            case "register":
+                if (parts.length != 4) {
+                    System.out.println("Invalid register format. Use: {command:register:username:name:password}");
+                    return null;
+                }
+                JSONObject registerJson = new JSONObject()
+                        .put("command", "register")
+                        .put("username", parts[1])
+                        .put("name", parts[2])
+                        .put("password", parts[3])
+                        .put("role", Hierarchy.LOW.name());
+
+                // Debug log
+                LOGGER.info("Sending registration JSON: " + registerJson.toString());
+
+                return registerJson.toString();
+            default:
+                LOGGER.warning("Unknown command: " + command);
+                System.out.println("Unknown command. Type {command:help} for available commands.");
+                return null;
+        }
+    }
+
+    private static void displayHelp() {
+        System.out.println("\nAvailable Commands:");
+        System.out.println("------------------");
+        System.out.println("{command:register:username:name:password} - Register with the server");
+        System.out.println("Example: {command:register:leo:Leandro:0808wq21}");
+        System.out.println("{command:help} - Display this help message");
+        System.out.println("\nMessage Formats:");
+        System.out.println("---------------");
+        System.out.println("Regular message: text");
+        System.out.println("Direct message:  @username: message");
+        System.out.println("Group message:   #groupname: message");
+        System.out.println("Request:         !request @username: content");
+        System.out.println();
+    }
+
+    private static String createRegistrationJson() {
+        JSONObject json = new JSONObject()
+                .put("command", "register")
+                .put("username", networkManager.getUsername())
+                .put("name", networkManager.getUsername()) // Using username as name for now
+                .put("password", "default") // Should be handled properly in production
+                .put("role", Hierarchy.LOW.name()); // Using LOW as the default hierarchy level
+
+        return json.toString();
+    }
+
+    private static String createLoginJson() {
+        JSONObject json = new JSONObject()
+                .put("command", "login")
+                .put("username", networkManager.getUsername())
+                .put("password", "default"); // Should be handled properly in production
+
+        return json.toString();
+    }
+
+    private static String handleMessage(ConnType connType, String input) {
+        try {
+            JSONObject messageJson;
+
+            if (input.startsWith("!request")) {
+                // Handle request
+                String[] parts = input.substring(9).split(":", 2);
+                if (parts.length != 2 || !parts[0].startsWith("@")) {
+                    System.out.println("Invalid request format. Use: !request @username: content");
+                    return null;
+                }
+                String destination = parts[0].substring(1).trim();
+                messageJson = ChatMessageHandler.createRequest(destination, parts[1].trim());
+            } else if (input.startsWith("@")) {
+                // Handle direct message
+                String[] parts = input.substring(1).split(":", 2);
+                if (parts.length != 2) {
+                    System.out.println("Invalid direct message format. Use: @username: message");
+                    return null;
+                }
+                messageJson = ChatMessageHandler.createMessage(parts[0].trim(), parts[1].trim());
+            } else if (input.startsWith("#")) {
+                // Handle group message
+                String[] parts = input.substring(1).split(":", 2);
+                if (parts.length != 2) {
+                    System.out.println("Invalid group message format. Use: #groupname: message");
+                    return null;
+                }
+                String groupName = parts[0].trim();
+                ChatMessageHandler.announceJoinGroup(groupName); // Join group first
+                messageJson = ChatMessageHandler.createMessage(groupName, parts[1].trim());
+            } else {
+                // Handle broadcast message
+                messageJson = ChatMessageHandler.createMessage("", input);
+            }
+
+            return messageJson.toString();
+
+        } catch (Exception e) {
+            LOGGER.log(Level.WARNING, "Failed to process message: " + e.getMessage());
+            return null;
+        }
+    }
+}

main/src/main/java/sd/CruzamentoServer.java

@@ -1,34 +0,0 @@
-package sd;
-
-import java.io.IOException;
-import java.net.ServerSocket;
-import java.net.Socket;
-
-public class CruzamentoServer {
-    public static void main(String[] args) {
-        // ... Inicializa Semáforos (Threads) ...
-        // ... Inicializa as Estruturas de Dados ...
-
-        try (ServerSocket serverSocket = new ServerSocket(portaDoCruzamento)) {
-            while (true) {
-                Socket clienteSocket = serverSocket.accept();
-                // Cria uma Thread de atendimento para lidar com o Veículo/Cliente
-                new Thread(new AtendenteVeiculo(clienteSocket)).start(); 
-            }
-        } catch (IOException e) { /* ... */ }
-    }
-    
-    // Método chamado pelo AtendenteVeiculo para gerenciar o tráfego
-    public synchronized boolean tentarPassar(Veiculo veiculo, String direcao) {
-        // 1. Veículo entra na fila da direção
-        // 2. Verifica o estado do semáforo da direção:
-        Semaforo semaforo = getSemaforo(direcao);
-        semaforo.esperarPeloVerde(); // O Veículo fica bloqueado se for vermelho
-        
-        // 3. Após o verde: 
-        //    - Remove da fila
-        //    - Permite a passagem (envia resposta de volta ao Veículo cliente)
-        // 4. Envia estatística de passagem ao Simulador Principal (Cliente TCP)
-        return true;
-    }
-}

main/src/main/java/sd/Main.java

@@ -1,7 +0,0 @@
-package sd;
-
-public class Main {
-    public static void main(String[] args) {
-        System.out.println("Hello world!");
-    }
-}

main/src/main/java/sd/Semaforo.java

@@ -1,47 +0,0 @@
-package sd;
-
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-
-public class Semaforo extends Thread {
-    // ... atributos ...
-    private final Lock semaforoLock; // Para sincronizar acesso ao estado
-    private final Condition verdeCondition; // Para Veículos esperarem pelo verde
-
-    public Semaforo(...) {
-        this.semaforoLock = new ReentrantLock();
-        this.verdeCondition = semaforoLock.newCondition();
-    }
-
-    @Override
-    public void run() {
-        while (true) {
-            // Ciclo de tempo (ajustável para controle)
-            estado = Estado.VERMELHO;
-            // Notificar o Cruzamento sobre o estado
-            try {
-                Thread.sleep(tempoVermelho);
-                estado = Estado.VERDE;
-                // Ao ficar VERDE, notifica as threads Veículo que estão esperando
-                semaforoLock.lock();
-                try {
-                    verdeCondition.signalAll(); 
-                } finally {
-                    semaforoLock.unlock();
-                }
-                Thread.sleep(tempoVerde);
-            } catch (InterruptedException e) { /* ... */ }
-        }
-    }
-    // Método para a thread Veículo esperar
-    public void esperarPeloVerde() throws InterruptedException {
-        semaforoLock.lock();
-        try {
-            if (estado == Estado.VERMELHO) {
-                verdeCondition.await(); 
-            }
-        } finally {
-            semaforoLock.unlock();
-        }
-    }
-}

main/src/main/java/sd/Veiculo.java

@@ -1,35 +0,0 @@
-package sd;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.net.Socket;
-
-public class Veiculo implements Runnable {
-    // ...
-    private String proximoCruzamentoIP; 
-    private int proximoCruzamentoPorta;
-
-    public void run() {
-        // Simular o movimento na rua (Thread.sleep(t))
-        
-        // 1. Tenta se conectar ao próximo Cruzamento
-        try (Socket socket = new Socket(proximoCruzamentoIP, proximoCruzamentoPorta);
-             ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
-             ObjectInputStream in = new ObjectInputStream(socket.getInputStream())) {
-
-            // Envia o objeto Veículo com a solicitação de passagem
-            out.writeObject(this); 
-            
-            // 2. BLOQUEIA a Thread, esperando a resposta do Servidor/Cruzamento
-            String permissao = (String) in.readObject(); 
-            
-            if ("OK_PASSAR".equals(permissao)) {
-                // Simular tempo de travessia do cruzamento (pequeno Thread.sleep())
-                // Atualiza a rota (próximo nó)
-            }
-            
-        } catch (IOException | ClassNotFoundException e) { /* ... */ }
-        // ... continua o loop da rota até a Saída (S) ...
-    }
-}

main/src/main/java/server/Server.java

@@ -0,0 +1,95 @@
+package server;
+
+import java.io.IOException;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+import java.net.ServerSocket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.logging.Logger;
+
+import server.structs.SystemStateManager;
+import server.handlers.ActiveUsersHandler;
+import server.handlers.BroadcastHandler;
+import server.handlers.UnicastHandler;
+import server.handlers.DataPersistence;
+import server.handlers.ThingHandler;
+import server.handlers.MulticastHandler;
+//import server.handlers.RequestsStatsThread;
+
+/**
+ * The Server class represents the main server application.
+ * It handles direct connections, broadcasts, multicasts, events, active users, request statistics,
+ * data persistence, and provides methods for starting and closing the server.
+ */
+public class Server {
+    private static final Logger logger = Logger.getLogger(Server.class.getName());
+    private static final ExecutorService executorService = Executors.newFixedThreadPool(100);
+
+    public static final int BUFFER_SIZE = 1024;
+    public static final int SERVER_PORT = 7500;
+    public static final int USER_PORT = 7501;
+    public static final int MULTICAST_PORT = 7502;
+    public static final String BROADCAST_ADDRESS = "255.255.255.255";
+
+    /**
+     * The main method of the Server class.
+     * It loads the shared data, creates sockets, and starts various threads for server operations.
+     *
+     * @param args The command line arguments.
+     */
+    public static void main(String[] args) {
+        try {
+            SystemStateManager.loadData();
+        } catch (Exception ignored) {
+        }
+
+        executorService.execute(() -> handleUnicast(SERVER_PORT));
+
+        try {
+            SystemStateManager.setMulticastSocket(new MulticastSocket(MULTICAST_PORT));
+            DatagramSocket broadcastSocket = new DatagramSocket(USER_PORT, InetAddress.getByName(BROADCAST_ADDRESS));
+            broadcastSocket.setBroadcast(true);
+            SystemStateManager.setBroadcastSocket(broadcastSocket);
+        } catch (IOException io) {
+            logger.severe("Error Creating Sockets! " + io.getMessage());
+            close();
+        }
+
+        executorService.execute(new BroadcastHandler());
+        executorService.execute(new MulticastHandler());
+        executorService.execute(new ThingHandler());
+        executorService.execute(new ActiveUsersHandler());
+        //executorService.execute(new RequestsStats());
+        executorService.execute(new DataPersistence());
+    }
+
+    /**
+     * Handles direct connections on the specified port.
+     *
+     * @param port The port number for direct connections.
+     */
+    public static void handleUnicast(int port) {
+        try (ServerSocket serverSocket = new ServerSocket(port)) {
+            while (true) {
+                executorService.execute(new UnicastHandler(serverSocket.accept()));
+            }
+        } catch (Exception e) {
+            logger.severe("Error Handling Unicast Connection! " + e.getMessage());
+            close();
+        }
+    }
+
+    /**
+     * Closes the server by shutting down the executor service, saving the shared data, and exiting the application.
+     */
+    public static void close() {
+        try {
+            executorService.shutdown();
+            SystemStateManager.saveData();
+            System.exit(0);
+        } catch (Exception ignored) {
+        }
+    }
+}

main/src/main/java/server/handlers/AcceptRequestHandler.java

@@ -0,0 +1,195 @@
+package server.handlers;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import server.Server;
+import server.structs.SystemStateManager;
+import server.structs.intfaces.Request;
+import server.structs.intfaces.User;
+import server.utils.MessageProtocolHandler;
+import server.utils.UserHandler;
+import shared.enums.ConnType;
+
+/**
+ * Handles asynchronous request acceptance in the emergency communication system.
+ * Manages the workflow of request acceptance based on connection type and user hierarchy.
+ *
+ * Features:
+ * - Multi-mode communication support (unicast, multicast, broadcast)
+ * - Hierarchy-based request handling
+ * - Asynchronous operation
+ * - Request acknowledgment tracking
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ */
+public class AcceptRequestHandler implements Runnable {
+    private static final Logger logger = Logger.getLogger(AcceptRequestHandler.class.getName());
+    private static final String MULTICAST_ADDRESS_PATTERN =
+            "^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})"
+                    + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+                    + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+                    + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$";
+
+    private final ConnType connectionType;
+    private final Request request;
+
+    /**
+     * Creates a new request acceptance handler.
+     *
+     * @param connectionType the type of network connection to use
+     * @param request the request to be processed
+     */
+    public AcceptRequestHandler(ConnType connectionType, Request request) {
+        this.connectionType = connectionType;
+        this.request = request;
+    }
+
+    @Override
+    public void run() {
+        try {
+            JSONObject requestJson = createRequestJson();
+            handleRequestByConnectionType(requestJson);
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Failed to send request answer", e);
+        } catch (JSONException e) {
+            logger.log(Level.SEVERE, "Failed to create request JSON", e);
+        }
+    }
+
+    private JSONObject createRequestJson() throws JSONException {
+        JSONObject json = new JSONObject();
+        json.put("command", "requestAnswer");
+        json.put("from", request.getSender());
+        json.put("content", request.getMessage());
+        json.put("to", determineReceiver());
+        return json;
+    }
+
+    private String determineReceiver() {
+        Object receiver = request.getReceiver();
+        if (receiver instanceof User) {
+            return ((User) receiver).getUsername();
+        }
+        if (receiver instanceof String) {
+            String receiverStr = (String) receiver;
+            if ("broadcast".equals(receiverStr) || receiverStr.matches(MULTICAST_ADDRESS_PATTERN)) {
+                return receiverStr;
+            }
+            logger.severe("Invalid receiver string format");
+            throw new IllegalStateException("Invalid receiver format");
+        }
+        logger.severe("Invalid receiver type");
+        throw new IllegalStateException("Invalid receiver type");
+    }
+
+    private void handleRequestByConnectionType(JSONObject requestJson) throws IOException, JSONException {
+        switch (connectionType) {
+            case UNICAST:
+                handleUnicastRequest(requestJson);
+                break;
+            case MULTICAST:
+                handleMulticastRequest(requestJson);
+                break;
+            case BROADCAST:
+                handleBroadcastRequest(requestJson);
+                break;
+            default:
+                logger.warning("Unsupported connection type: " + connectionType);
+        }
+    }
+
+    private void handleUnicastRequest(JSONObject requestJson) throws IOException, JSONException {
+        User receiver = request.getReceiver();
+        String response = UserHandler.sendAndReceiveSomething(receiver, requestJson.toString());
+
+        if (response != null && new JSONObject(response).getString("response").equals("YES")) {
+            request.setTruster(receiver);
+            notifyUsers(receiver);
+        }
+    }
+
+    private void handleMulticastRequest(JSONObject requestJson) throws IOException, JSONException {
+        User group = request.getReceiver(); // Now correctly returns a User
+        List<User> eligibleUsers = getEligibleUsers(
+                new ArrayList<>(SystemStateManager.getUsersFromGroup(group.getUsername())), // Assuming you want to get users from the group name
+                request.getSender()
+        );
+
+        for (User user : eligibleUsers) {
+            if (tryAcceptRequest(user, requestJson)) {
+                sendMulticastNotification(group.toString());
+                break;
+            }
+        }
+    }
+
+    private void handleBroadcastRequest(JSONObject requestJson) throws IOException, JSONException {
+        List<User> eligibleUsers = getEligibleUsers(
+                new ArrayList<>(SystemStateManager.getUsers()),
+                request.getSender()
+        );
+
+        for (User user : eligibleUsers) {
+            if (tryAcceptRequest(user, requestJson)) {
+                sendBroadcastNotification();
+                break;
+            }
+        }
+    }
+
+    private List<User> getEligibleUsers(List<User> users, User sender) {
+        users.remove(sender);
+        users.removeIf(user -> !SystemStateManager.getOnlineUsers().contains(user));
+        users.removeIf(user -> !user.getHierarchy().isHigherThan(sender.getHierarchy()));
+        users.sort((u1, u2) -> u2.getHierarchy().getValue() - u1.getHierarchy().getValue());
+        return users;
+    }
+
+    private boolean tryAcceptRequest(User user, JSONObject requestJson) throws IOException, JSONException {
+        String response = UserHandler.sendAndReceiveSomething(user, requestJson.toString());
+        if (response != null && new JSONObject(response).getString("response").equals("YES")) {
+            request.setTruster(user);
+            return true;
+        }
+        return false;
+    }
+
+    private void notifyUsers(User receiver) throws IOException {
+        UserHandler.sendSomething(request.getSender(),
+                MessageProtocolHandler.notificationToJson(request).toString());
+        UserHandler.sendSomething(receiver,
+                MessageProtocolHandler.notificationToJson(request).toString());
+    }
+
+    private void sendMulticastNotification(String group) throws IOException {
+        String eventJson = MessageProtocolHandler.notificationToJson(request).toString();
+        DatagramPacket packet = new DatagramPacket(
+                eventJson.getBytes(),
+                eventJson.length(),
+                InetAddress.getByName(group),
+                Server.MULTICAST_PORT
+        );
+        SystemStateManager.getMulticastSocket().send(packet);
+    }
+
+    private void sendBroadcastNotification() throws IOException {
+        String eventJson = MessageProtocolHandler.notificationToJson(request).toString();
+        DatagramPacket packet = new DatagramPacket(
+                eventJson.getBytes(),
+                eventJson.length(),
+                InetAddress.getByName(Server.BROADCAST_ADDRESS),
+                Server.USER_PORT
+        );
+        SystemStateManager.getBroadcastSocket().send(packet);
+    }
+}

main/src/main/java/server/handlers/ActiveUsersHandler.java

@@ -0,0 +1,61 @@
+package server.handlers;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import server.structs.SystemStateManager;
+import server.structs.intfaces.User;
+import server.utils.UserHandler;
+
+/**
+ * This class represents a thread that periodically checks the number of online users and sends a message to the user with the highest role.
+ */
+public class ActiveUsersHandler implements Runnable {
+
+    private static final Logger logger = Logger.getLogger(ActiveUsersHandler.class.getName());
+
+    /**
+     * The run method of the ActiveUsersThread class.
+     * This method is executed when the thread starts.
+     * It periodically checks the number of online users and sends a message to the user with the highest role.
+     */
+    @Override
+    public void run() {
+        // Number of Online Users Only for the highest role
+        while (true) {
+            try {
+                Thread.sleep(10000);
+            } catch (InterruptedException ignored) {
+                Thread.currentThread().interrupt();
+            }
+            List<User> onlineUsers = SystemStateManager.getOnlineUsers();
+            logger.info("Number of Online Users: " + onlineUsers.size());
+            if (onlineUsers.size() == 0) {
+                continue;
+            }
+            User highestRoleUser = SystemStateManager.getHighestHierarchyUser(onlineUsers);
+            if (highestRoleUser == null) {
+                logger.severe("Highest Role User is null!");
+                continue;
+            }
+            try {
+                JSONObject jsonObject = new JSONObject();
+                jsonObject.put("command", "message");
+                jsonObject.put("from", "server");
+                jsonObject.put("to", highestRoleUser.getUsername());
+                jsonObject.put("content", "Number of Online Users: " + onlineUsers.size());
+                SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm");
+                jsonObject.put("date", sdf.format(new Date()));
+                UserHandler.sendSomething(highestRoleUser, jsonObject.toString());
+            } catch (IOException | JSONException ignored) {
+                logger.severe("Error Sending Active Users! " + ignored.getMessage());
+            }
+        }
+    }
+}

main/src/main/java/server/handlers/BroadcastHandler.java

@@ -0,0 +1,57 @@
+package server.handlers;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.util.logging.Logger;
+
+import server.Server;
+import server.structs.SystemStateManager;
+import server.utils.InputCommandRouter;
+import server.utils.InputCommandRouter;
+import shared.enums.ConnType;
+
+/**
+ * The BroadcastThread class represents a thread that handles broadcasting messages to all connected clients.
+ */
+public class BroadcastHandler implements Runnable {
+    private static final Logger logger = Logger.getLogger(BroadcastHandler.class.getName());
+
+    /**
+     * Constructs a new BroadcastThread.
+     */
+    public BroadcastHandler() {}
+
+    /**
+     * Runs the broadcast thread.
+     */
+    @Override
+    public void run() {
+        try (
+                DatagramSocket broadcastSocket = SystemStateManager.getBroadcastSocket();
+        ) {
+            while (true) {
+                byte[] buffer = new byte[Server.BUFFER_SIZE];
+                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+                broadcastSocket.receive(packet);
+                if (packet.getAddress().equals(InetAddress.getLocalHost())) {
+                    continue;
+                }
+                String input = new String(packet.getData());
+                String output = InputCommandRouter.processInput(ConnType.BROADCAST, packet, input);
+                if (output == null) {
+                    continue;
+                }
+                DatagramPacket response = new DatagramPacket(output.getBytes(), output.length(), packet.getAddress(), packet.getPort());
+                try {
+                    broadcastSocket.send(response);
+                } catch (IOException io) {
+                    logger.severe("Error Sending Broadcast Response: " + io.getMessage());
+                }
+            }
+        } catch (IOException io) {
+            logger.severe("Error Handling Broadcast Connection! " + io.getMessage());
+        }
+    }
+}

main/src/main/java/server/handlers/DataPersistence.java

@@ -0,0 +1,30 @@
+package server.handlers;
+
+import java.util.logging.Logger;
+
+import server.structs.SystemStateManager;
+
+/**
+ * This class represents a thread responsible for persisting data at regular intervals.
+ */
+public class DataPersistence implements Runnable {
+
+    private static final Logger logger = Logger.getLogger(DataPersistence.class.getName());
+
+    /**
+     * The run method of the DataPersistenceThread.
+     * This method is responsible for saving data at regular intervals.
+     */
+    @Override
+    public void run() {
+        while (true) {
+            try {
+                Thread.sleep(10000);
+                SystemStateManager.saveData();
+                logger.info("Data Saved");
+            } catch (Exception e) {
+                logger.severe("Error Saving Data! " + e.getMessage());
+            }
+        }
+    }
+}

main/src/main/java/server/handlers/MessageHistoryHandler.java

@@ -0,0 +1,57 @@
+package server.handlers;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import server.structs.SystemStateManager;
+import server.structs.intfaces.Notification;
+import server.structs.intfaces.User;
+import server.utils.MessageProtocolHandler;
+import server.utils.UserHandler;
+
+
+/**
+ * This class represents a thread that retrieves and sends message history for a user.
+ */
+public class MessageHistoryHandler implements Runnable {
+    private static final Logger logger = Logger.getLogger(MessageHistoryHandler.class.getName());
+
+    private User user;
+
+    /**
+     * Constructs a new MessageHistoryThread object.
+     *
+     * @param user the user for whom the message history will be retrieved and sent
+     */
+    public MessageHistoryHandler(User user) {
+        this.user = user;
+    }
+
+    /**
+     * Runs the thread, retrieving and sending the message history for the user.
+     */
+    @Override
+    public void run() {
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException ignored) {
+            Thread.currentThread().interrupt();
+        }
+        List<? extends Notification> notifications = SystemStateManager.getUserNotifications(user);
+        if (notifications.isEmpty()) {
+            return;
+        }
+        JSONObject jsonObject = new JSONObject();
+        try {
+            jsonObject.put("command", "history");
+            jsonObject.put("notifications", MessageProtocolHandler.notificationsToJson(notifications));
+            UserHandler.sendSomething(user, jsonObject.toString());
+        } catch (JSONException | IOException error) {
+            logger.severe("Error Sending Message History! " + error.getMessage());
+        }
+    }
+}

main/src/main/java/server/handlers/MulticastHandler.java

@@ -0,0 +1,58 @@
+package server.handlers;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+import java.util.logging.Logger;
+
+import server.Server;
+import server.structs.SystemStateManager;
+import server.utils.InputCommandRouter;
+import shared.enums.ConnType;
+
+/**
+ * MulticastThread class.
+ * This class is responsible for handling the multicast connection.
+ * It receives multicast packets, processes them, and sends responses back to the clients.
+ */
+public class MulticastHandler implements Runnable {
+    private static final Logger logger = Logger.getLogger(MulticastHandler.class.getName());
+
+    /**
+     * MulticastThread constructor.
+     */
+    public MulticastHandler() {}
+
+    /**
+     * Runs the multicast thread.
+     * It continuously receives multicast packets, processes them, and sends responses back to the clients.
+     */
+    @Override
+    public void run() {
+        try (
+                MulticastSocket multicastSocket = SystemStateManager.getMulticastSocket()) {
+            while (true) {
+                byte[] buffer = new byte[Server.BUFFER_SIZE];
+                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+                multicastSocket.receive(packet);
+                if (packet.getAddress().equals(InetAddress.getLocalHost())) {
+                    continue;
+                }
+                String input = new String(packet.getData());
+                String output = InputCommandRouter.processInput(ConnType.MULTICAST, packet, input);
+                if (output == null) {
+                    continue;
+                }
+                DatagramPacket response = new DatagramPacket(output.getBytes(), output.length(), packet.getAddress(), packet.getPort());
+                try {
+                    multicastSocket.send(response);
+                } catch (IOException io) {
+                    logger.severe("Error sending Multicast Response: " + io.getMessage());
+                }
+            }
+        } catch (IOException io) {
+            logger.severe("Error Handling Multicast Connection! " + io.getMessage());
+        }
+    }
+}

main/src/main/java/server/handlers/ThingHandler.java

@@ -0,0 +1,119 @@
+package server.handlers;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import server.Server;
+import server.structs.SystemStateManager;
+import server.structs.intfaces.Notification;
+import server.structs.intfaces.Message;
+import server.structs.intfaces.Request;
+import server.structs.intfaces.User;
+import server.utils.MessageProtocolHandler;
+
+/**
+ * Handles the delivery of notifications to users in a server-side communication system.
+ *
+ * This class is a runnable thread responsible for continuously processing and delivering
+ * notifications from the system state manager to their intended recipients. It manages
+ * different types of notifications such as messages and requests, ensuring they are
+ * transmitted to the appropriate users via network sockets.
+ *
+ * Key responsibilities:
+ * <ul>
+ *   <li>Periodically retrieves pending notifications from the system state manager</li>
+ *   <li>Validates and delivers notifications to their intended users</li>
+ *   <li>Handles socket connections and communication protocols</li>
+ *   <li>Manages error scenarios such as closed sockets or failed JSON conversions</li>
+ * </ul>
+ *
+ * The handler operates in an infinite loop, sleeping briefly between notification checks
+ * to prevent excessive CPU usage. It supports different notification types and logs
+ * critical events for monitoring and debugging purposes.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ * @see SystemStateManager
+ * @see Notification
+ * @see Message
+ * @see Request
+ */
+public class ThingHandler implements Runnable {
+
+    private static final Logger logger = Logger.getLogger(ThingHandler.class.getName());
+
+    /**
+     * The run method is the entry point for the thread.
+     * It continuously checks for events in the shared object and delivers them to the appropriate users.
+     */
+    @Override
+    public void run() {
+        while (true) {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException ignored) {
+                Thread.currentThread().interrupt();
+            }
+            List<? extends Notification> notifications = SystemStateManager.getNotificationsToDeliver();
+            logger.info("Notifications to deliver: " + notifications.size());
+            for (int i = 0; i < notifications.size(); i++) {
+                Notification notification = notifications.get(i);
+
+                Object receiver = notification.getReceiver();
+
+                if (receiver instanceof User) {
+                    User user = ((User) receiver);
+                    logger.info("Event to deliver to " + user.getUsername());
+                    Socket socket = SystemStateManager.getUserSocket(user);
+                    if (socket == null || socket.isClosed() || !socket.isConnected()) {
+                        logger.severe("User Socket is Null or Closed");
+                        SystemStateManager.removeNotificationDelivered(notification);
+                        continue;
+                    }
+                    try (
+                            Socket newSocket = new Socket(socket.getInetAddress(), Server.USER_PORT);
+                            BufferedReader in = new BufferedReader(new InputStreamReader(newSocket.getInputStream()));
+                            PrintWriter out = new PrintWriter(newSocket.getOutputStream(), true)) {
+                        if (notification instanceof Message) {
+                            Message message = ((Message) notification);
+                            JSONObject json = MessageProtocolHandler.notificationToJson(message);
+                            if (json == null) {
+                                logger.severe("Event to JSON returned null!");
+                                SystemStateManager.removeNotificationDelivered(notification);
+                                continue;
+                            }
+                            out.println(MessageProtocolHandler.notificationToJson(message).toString());
+                            logger.info("Message delivered to " + user.getUsername());
+                        } else if (notification instanceof Request) {
+                            Request request = ((Request) notification);
+                            JSONObject json = MessageProtocolHandler.notificationToJson(request);
+                            if (json == null) {
+                                logger.severe("Event to JSON returned null!");
+                                SystemStateManager.removeNotificationDelivered(notification);
+                                continue;
+                            }
+                            out.println(MessageProtocolHandler.notificationToJson(request).toString());
+                            logger.info("Request delivered to " + user.getUsername());
+                        }
+                        SystemStateManager.removeNotificationDelivered(notification);
+                    } catch (IOException io) {
+                        SystemStateManager.removeUserSocket(user);
+                    } catch (JSONException json) {
+                        SystemStateManager.removeNotificationDelivered(notification);
+                    }
+                } else {
+                    logger.severe("Receiver is not a user!");
+                    SystemStateManager.removeNotificationDelivered(notification);
+                }
+            }
+        }
+    }
+}

main/src/main/java/server/handlers/UnicastHandler.java

@@ -0,0 +1,60 @@
+package server.handlers;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.util.logging.Logger;
+
+import server.utils.InputCommandRouter;
+import shared.enums.ConnType;
+
+/**
+ * Represents a thread that handles direct connections with clients.
+ */
+public class UnicastHandler implements Runnable {
+    private static final Logger logger = Logger.getLogger(UnicastHandler.class.getName());
+
+    private Socket socket;
+
+    /**
+     * Constructs a DirectThread object with the specified socket.
+     *
+     * @param socket the socket representing the client connection
+     */
+    public UnicastHandler(Socket socket) {
+        this.socket = socket;
+    }
+
+    /**
+     * Runs the thread and handles the communication with the client.
+     */
+    @Override
+    public void run() {
+        try (
+                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);) {
+            try {
+                while (true) {
+                    String input = in.readLine();
+                    if (input == null) {
+                        in.close();
+                        out.close();
+                        if (!socket.isClosed()) socket.close();
+                        return;
+                    }
+                    String output = InputCommandRouter.processInput(ConnType.UNICAST, socket, input);
+                    if (output == null) {
+                        continue;
+                    }
+                    out.println(output);
+                }
+            } catch (IOException io) {
+                logger.severe("Error Handling Direct Message! " + io.getMessage());
+            }
+        } catch (IOException io) {
+            logger.severe("Error Handling Direct Connection! " + io.getMessage());
+        }
+    }
+}

main/src/main/java/server/structs/SystemStateManager.java

@@ -0,0 +1,453 @@
+package server.structs;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.util.stream.Collectors;
+import server.structs.intfaces.*;
+import shared.enums.Hierarchy;
+
+/**
+ * Manages network communications and user data for the emergency chat server.
+ * Implements thread-safe operations for managing users, connections, and messages.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public class SystemStateManager {
+    // Maps usernames to their corresponding User objects for quick lookup
+    private static final Map<String, User> users = new HashMap<>();
+    // Maintains active socket connections for online users
+    private static final Map<User, Socket> userSockets = new HashMap<>();
+    // Stores pending notifications for each user in priority order
+    private static final Map<User, TreeSet<Notification>> userNotifications = new HashMap<>();
+    // Queue of notifications pending delivery to users
+    private static final List<Notification> notificationsToDeliver = new ArrayList<>();
+    // Maps multicast group addresses to their member users
+    private static final Map<String, List<User>> groups = new HashMap<>();
+    // Socket for handling multicast communication
+    private static MulticastSocket multicastSocket;
+    // Socket for handling broadcast messages
+    private static DatagramSocket broadcastSocket;
+
+    // Private constructor to prevent instantiation
+    private SystemStateManager() {
+        throw new AssertionError("Utility class - do not instantiate");
+    }
+
+    //#region User Management
+    /**
+     * Adds a new user to the system.
+     *
+     * @param user the user to be added
+     * @throws IllegalArgumentException if user is null or if username already exists
+     */
+    public static void addUser(User user) {
+        validateNotNull("User", user);
+        synchronized (users) {
+            if (users.containsKey(user.getUsername())) {
+                throw new IllegalArgumentException("User already exists!");
+            }
+            users.put(user.getUsername(), user);
+        }
+    }
+
+    /**
+     * Retrieves a user by their username.
+     *
+     * @param username the username to look up
+     * @return the User object if found, null otherwise
+     * @throws IllegalArgumentException if username is null or empty
+     */
+    public static User getUser(String username) {
+        validateNotEmpty("Username", username);
+        synchronized (users) {
+            return users.get(username);
+        }
+    }
+
+    /**
+     * Returns a list of all registered users in the system.
+     *
+     * @return new ArrayList containing all users
+     */
+    public static List<User> getUsers() {
+        synchronized (users) {
+            return new ArrayList<>(users.values());
+        }
+    }
+
+    /**
+     * Gets the user with the highest hierarchy level from a list of users.
+     *
+     * @param userList list of users to check
+     * @return user with highest hierarchy level, or null if list is empty
+     */
+    public static User getHighestHierarchyUser(List<User> userList) {
+        if (userList == null || userList.isEmpty()) {
+            return null;
+        }
+
+        return userList.stream()
+                .max((u1, u2) -> {
+                    Hierarchy h1 = u1.getHierarchy();
+                    Hierarchy h2 = u2.getHierarchy();
+                    return Integer.compare(h1.getValue(), h2.getValue());
+                })
+                .orElse(null);
+    }
+    //#endregion
+
+    //#region Socket Management
+    /**
+     * Associates a socket connection with a user.
+     *
+     * @param user the user to associate the socket with
+     * @param socket the socket connection
+     * @throws IllegalArgumentException if either parameter is null
+     */
+    public static void addUserSocket(User user, Socket socket) {
+        validateNotNull("User", user);
+        validateNotNull("Socket", socket);
+        synchronized (userSockets) {
+            userSockets.put(user, socket);
+        }
+    }
+
+    /**
+     * Retrieves the active socket connection for a user.
+     *
+     * @param user the user whose socket to retrieve
+     * @return the Socket object if found, null otherwise
+     * @throws IllegalArgumentException if user is null
+     */
+    public static Socket getUserSocket(User user) {
+        validateNotNull("User", user);
+        synchronized (userSockets) {
+            return userSockets.get(user);
+        }
+    }
+
+    /**
+     * Returns a list of currently online users.
+     * A user is considered online if they have an active socket connection.
+     *
+     * @return list of users with active socket connections
+     */
+    public static List<User> getOnlineUsers() {
+        synchronized (userSockets) {
+            return userSockets.entrySet().stream()
+                    .filter(entry -> isSocketActive(entry.getValue()))
+                    .map(Map.Entry::getKey)
+                    .collect(Collectors.toList());
+        }
+    }
+
+    /**
+     * Checks if a socket connection is active and valid.
+     *
+     * @param socket the socket to check
+     * @return true if socket is active and operational
+     */
+    private static boolean isSocketActive(Socket socket) {
+        return socket != null &&
+                !socket.isClosed() &&
+                socket.isConnected() &&
+                !socket.isInputShutdown() &&
+                !socket.isOutputShutdown();
+    }
+
+    /**
+     * Removes a user's socket connection.
+     *
+     * @param user the user whose socket to remove
+     * @throws IllegalArgumentException if user is null
+     */
+    public static void removeUserSocket(User user) {
+        validateNotNull("User", user);
+        synchronized (userSockets) {
+            userSockets.remove(user);
+        }
+    }
+    //#endregion
+
+    //#region Notification Management
+    /**
+     * Adds a notification for a specific user.
+     *
+     * @param user the target user
+     * @param notification the notification to add
+     * @throws IllegalArgumentException if either parameter is null
+     */
+    public static void addUserNotification(User user, Notification notification) {
+        validateNotNull("User", user);
+        validateNotNull("Notification", notification);
+        synchronized (userNotifications) {
+            userNotifications.computeIfAbsent(user, k -> new TreeSet<>()).add(notification);
+        }
+    }
+
+    /**
+     * Retrieves all notifications for a user.
+     *
+     * @param user the user whose notifications to retrieve
+     * @return list of notifications, empty list if none found
+     * @throws IllegalArgumentException if user is null
+     */
+    public static List<Notification> getUserNotifications(User user) {
+        validateNotNull("User", user);
+        synchronized (userNotifications) {
+            TreeSet<Notification> notifications = userNotifications.get(user);
+            return notifications != null ? new ArrayList<>(notifications) : new ArrayList<>();
+        }
+    }
+
+    /**
+     * Gets all pending requests in the system.
+     *
+     * @return list of all Request objects
+     */
+    public static List<Request> getRequests() {
+        synchronized (userNotifications) {
+            return userNotifications.values().stream()
+                    .flatMap(Collection::stream)
+                    .filter(notification -> notification instanceof Request)
+                    .map(notification -> (Request) notification)
+                    .collect(Collectors.toList());
+        }
+    }
+
+    /**
+     * Filters a collection of requests to return only accepted ones.
+     *
+     * @param requests collection of requests to filter
+     * @return list of requests that have been accepted
+     */
+    public static List<Request> getAcceptedRequests(Collection<Request> requests) {
+        return requests.stream()
+                .filter(request -> request.getTruster() != null)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Adds a notification to the delivery queue.
+     *
+     * @param notification the notification to queue
+     * @throws IllegalArgumentException if notification is null
+     */
+    public static void addNotificationToDeliver(Notification notification) {
+        validateNotNull("Notification", notification);
+        synchronized (notificationsToDeliver) {
+            notificationsToDeliver.add(notification);
+        }
+    }
+
+    /**
+     * Returns all notifications pending delivery.
+     *
+     * @return list of queued notifications
+     */
+    public static List<Notification> getNotificationsToDeliver() {
+        synchronized (notificationsToDeliver) {
+            return new ArrayList<>(notificationsToDeliver);
+        }
+    }
+
+    /**
+     * Removes a delivered notification from the queue.
+     *
+     * @param notification the notification to remove
+     * @throws IllegalArgumentException if notification is null
+     */
+    public static void removeNotificationDelivered(Notification notification) {
+        validateNotNull("Notification", notification);
+        synchronized (notificationsToDeliver) {
+            notificationsToDeliver.remove(notification);
+        }
+    }
+    //#endregion
+
+    //#region Group Management
+    /**
+     * Adds a user to a multicast group.
+     *
+     * @param group the multicast group address
+     * @param user the user to add
+     * @throws IllegalArgumentException if group is invalid or user is null
+     */
+    public static void addUserToGroup(String group, User user) {
+        validateNotEmpty("Group", group);
+        validateNotNull("User", user);
+        validateMulticastAddress(group);
+
+        synchronized (groups) {
+            groups.computeIfAbsent(group, k -> new ArrayList<>()).add(user);
+        }
+    }
+
+    /**
+     * Gets all users in a specific group.
+     *
+     * @param group the group address
+     * @return list of users in the group
+     * @throws IllegalArgumentException if group is null or empty
+     */
+    public static List<User> getUsersFromGroup(String group) {
+        validateNotEmpty("Group", group);
+        synchronized (groups) {
+            List<User> groupUsers = groups.get(group);
+            return groupUsers != null ? new ArrayList<>(groupUsers) : new ArrayList<>();
+        }
+    }
+    //#endregion
+
+    //#region Socket Getters/Setters
+    /**
+     * Gets the system's multicast socket.
+     *
+     * @return the MulticastSocket instance
+     */
+    public static MulticastSocket getMulticastSocket() {
+        return multicastSocket;
+    }
+
+    /**
+     * Sets the system's multicast socket.
+     *
+     * @param socket the MulticastSocket to use
+     */
+    public static void setMulticastSocket(MulticastSocket socket) {
+        multicastSocket = socket;
+    }
+
+    /**
+     * Gets the system's broadcast socket.
+     *
+     * @return the DatagramSocket instance
+     */
+    public static DatagramSocket getBroadcastSocket() {
+        return broadcastSocket;
+    }
+
+    /**
+     * Sets the system's broadcast socket.
+     *
+     * @param socket the DatagramSocket to use
+     */
+    public static void setBroadcastSocket(DatagramSocket socket) {
+        broadcastSocket = socket;
+    }
+    //#endregion
+
+    //#region Data Persistence
+    /**
+     * Gets a map of all data structures for persistence.
+     *
+     * @return map of structure names to their objects
+     */
+    private static Map<String, Object> getDataStructures() {
+        Map<String, Object> structures = new HashMap<>();
+        structures.put("users.bin", users);
+        structures.put("userNotifications.bin", userNotifications);
+        structures.put("notificationsToDeliver.bin", notificationsToDeliver);
+        structures.put("groups.bin", groups);
+        return structures;
+    }
+
+    /**
+     * Saves all system state to persistent storage.
+     *
+     * @throws IOException if an I/O error occurs during saving
+     */
+    public static void saveData() throws IOException {
+        for (Map.Entry<String, Object> entry : getDataStructures().entrySet()) {
+            try (ObjectOutputStream out = new ObjectOutputStream(
+                    new FileOutputStream("./" + entry.getKey()))) {
+                out.writeObject(entry.getValue());
+            }
+        }
+    }
+
+    /**
+     * Loads system state from persistent storage.
+     *
+     * @throws IOException if an I/O error occurs during loading
+     * @throws ClassNotFoundException if a serialized class cannot be found
+     */
+    public static void loadData() throws IOException, ClassNotFoundException {
+        for (Map.Entry<String, Object> entry : getDataStructures().entrySet()) {
+            try (ObjectInputStream in = new ObjectInputStream(
+                    new FileInputStream(entry.getKey()))) {
+                Object data = in.readObject();
+                loadDataStructure(entry.getKey(), data);
+            }
+        }
+    }
+
+    /**
+     * Loads a specific data structure from serialized data.
+     *
+     * @param key the identifier for the data structure
+     * @param data the serialized data to load
+     */
+    private static void loadDataStructure(String key, Object data) {
+        switch (key) {
+            case "users.bin":
+                users.putAll((Map<String, User>) data);
+                break;
+            case "userNotifications.bin":
+                userNotifications.putAll((Map<User, TreeSet<Notification>>) data);
+                break;
+            case "notificationsToDeliver.bin":
+                notificationsToDeliver.addAll((List<Notification>) data);
+                break;
+            case "groups.bin":
+                groups.putAll((Map<String, List<User>>) data);
+                break;
+        }
+    }
+    //#endregion
+
+    //#region Validation Helpers
+    /**
+     * Validates that an object is not null.
+     *
+     * @param field name of the field being validated
+     * @param value the value to check
+     * @throws IllegalArgumentException if value is null
+     */
+    private static void validateNotNull(String field, Object value) {
+        if (value == null) {
+            throw new IllegalArgumentException(field + " cannot be null!");
+        }
+    }
+
+    /**
+     * Validates that a string is not null or empty.
+     *
+     * @param field name of the field being validated
+     * @param value the string to check
+     * @throws IllegalArgumentException if value is null or empty
+     */
+    private static void validateNotEmpty(String field, String value) {
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException(field + " cannot be null or empty!");
+        }
+    }
+
+    /**
+     * Validates that a string represents a valid multicast address.
+     *
+     * @param address the address to validate
+     * @throws IllegalArgumentException if address format is invalid
+     */
+    private static void validateMulticastAddress(String address) {
+        if (!address.matches("^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})"
+                + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+                + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+                + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$")) {
+            throw new IllegalArgumentException("Invalid multicast address format!");
+        }
+    }
+    //#endregion
+}

main/src/main/java/server/structs/abstractions/AbstractMessage.java

@@ -0,0 +1,28 @@
+package server.structs.abstractions;
+
+import server.structs.intfaces.Message;
+import server.structs.intfaces.User;
+
+/**
+ * Abstract implementation of Message interface for the emergency communication system.
+ * Represents the base message type that can be exchanged between users.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ * @see Message
+ * @see AbstractNotification
+ */
+public abstract class AbstractMessage extends AbstractNotification implements Message {
+
+    /**
+     * Creates a new message.
+     *
+     * @param sender   the user sending the message
+     * @param receiver the recipient (user, broadcast, or multicast group)
+     * @param content  the message content
+     * @throws IllegalArgumentException if sender or content is null
+     */
+    protected AbstractMessage(User sender, Object receiver, String content) {
+        super(sender, receiver, content);
+    }
+}

main/src/main/java/server/structs/abstractions/AbstractNotification.java

@@ -0,0 +1,111 @@
+package server.structs.abstractions;
+
+import java.time.Instant;
+import java.util.Objects;
+
+import server.structs.intfaces.Notification;
+import server.structs.intfaces.User;
+
+/**
+ * Abstract base implementation for notifications in the emergency communication system.
+ * Provides common functionality for all types of communications including
+ * messages, requests, and alerts.
+ *
+ * Features:
+ * - Timestamp-based ordering
+ * - Sender and receiver tracking
+ * - Message content storage
+ * - Thread-safe immutable timestamp
+ *
+ * @author 0x1eo
+ * @since 2024-12-13 02:47:23
+ * @see Notification
+ */
+public abstract class AbstractNotification implements Notification {
+    protected User sender;
+    protected User receiver;
+    protected String message;
+    protected final Instant timestamp;
+
+    /**
+     * Creates a new notification.
+     *
+     * @param sender   the sender's identifier object
+     * @param receiver the recipient's identifier object
+     * @param message  the notification message content
+     * @throws IllegalArgumentException if sender, receiver or message is null
+     */
+    protected AbstractNotification(Object sender, Object receiver, String message) {
+        setSender(sender);
+        setReceiver(receiver);
+        setMessage(message);
+        this.timestamp = Instant.now();
+    }
+
+    @Override
+    public User getSender() {
+        return sender;
+    }
+
+    @Override
+    public void setSender(Object sender) {
+        if (sender == null) {
+            throw new IllegalArgumentException("Sender cannot be null");
+        }
+        this.sender = (User)sender;
+    }
+
+    @Override
+    public User getReceiver() { return receiver; }
+
+    @Override
+    public void setReceiver(Object receiver) {
+        if (receiver == null) {
+            throw new IllegalArgumentException("Receiver cannot be null");
+        }
+        this.receiver = (User)receiver;
+    }
+
+    @Override
+    public String getMessage() { return message; }
+
+    @Override
+    public void setMessage(String message) {
+        if (message == null) {
+            throw new IllegalArgumentException("Message cannot be null");
+        }
+        this.message = message;
+    }
+
+    @Override
+    public Instant getTimestamp() { return timestamp; }
+
+    @Override
+    public void setTimestamp(Instant timestamp) {
+        throw new UnsupportedOperationException("Timestamp cannot be modified after creation");
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Notification)) return false;
+
+        Notification other = (Notification) obj;
+        return Objects.equals(sender, other.getSender()) &&
+                Objects.equals(receiver, other.getReceiver()) &&
+                Objects.equals(message, other.getMessage()) &&
+                Objects.equals(timestamp, other.getTimestamp());
+    }
+
+    @Override
+    public int hashCode() { return Objects.hash(sender, receiver, message, timestamp); }
+
+    @Override
+    public String toString() {
+        return String.format("Notification[from=%s, to=%s, message='%s', time=%s]",
+                sender,
+                receiver,
+                message,
+                timestamp);
+    }
+}

main/src/main/java/server/structs/abstractions/AbstractRequest.java

@@ -0,0 +1,88 @@
+package server.structs.abstractions;
+
+import server.structs.intfaces.Request;
+import server.structs.intfaces.User;
+
+/**
+ * Abstract base implementation for requests in the emergency communication system.
+ * Extends AbstractNotification to provide request-specific functionality including
+ * request author tracking.
+ *
+ * Features:
+ * - Request author (truster) tracking
+ * - Inherits notification base features
+ * - Supports emergency communication protocol
+ * - Immutable creation timestamp
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ * @see Request
+ * @see AbstractNotification
+ * @see User
+ */
+public abstract class AbstractRequest extends AbstractNotification implements Request {
+    protected User truster;
+
+    /**
+     * Creates a new request in the emergency system.
+     *
+     * @param sender   the user initiating the request
+     * @param receiver the intended recipient
+     * @param content  the request content/message
+     * @throws IllegalArgumentException if any parameter is null, or if receiver is empty
+     */
+    protected AbstractRequest(User sender, String receiver, String content) {
+        super(sender.getUsername(), receiver, content);
+        setTruster(sender);  // Initialize truster with the sender
+    }
+
+    /**
+     * Gets the author (requesting user) of this request.
+     *
+     * @return the user who authored this request
+     */
+    @Override
+    public User getTruster() {
+        return truster;
+    }
+
+    /**
+     * Sets the author (requesting user) of this request.
+     *
+     * @param author the user who authored this request
+     * @throws IllegalArgumentException if author is null
+     */
+    @Override
+    public void setTruster(User author) {
+        if (author == null) {
+            throw new IllegalArgumentException("Request author cannot be null");
+        }
+        this.truster = author;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("Request[from=%s, to=%s, content='%s', author=%s, time=%s]",
+                getSender(),
+                getReceiver(),
+                getMessage(),
+                truster.getUsername(),
+                getTimestamp());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!super.equals(obj)) return false;
+        if (!(obj instanceof Request)) return false;
+
+        Request other = (Request) obj;
+        return truster.equals(other.getTruster());
+    }
+
+    @Override
+    public int hashCode() {
+        int result = super.hashCode();
+        result = 31 * result + truster.hashCode();
+        return result;
+    }
+}

main/src/main/java/server/structs/abstractions/AbstractUser.java

@@ -0,0 +1,125 @@
+package server.structs.abstractions;
+
+import java.util.Objects;
+import server.structs.intfaces.User;
+import shared.enums.Hierarchy;
+
+/**
+ * Abstract base implementation of the User interface that represents
+ * a user in the emergency communication system with hierarchical privileges.
+ *
+ * Features:
+ * - Username and full name management
+ * - Secure password storage
+ * - Hierarchical role-based access
+ * - Natural ordering based on hierarchy
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ * @see User
+ * @see Hierarchy
+ */
+public abstract class AbstractUser implements User {
+    private String username;
+    private String name;
+    private String password;
+    private Hierarchy hierarchy;
+
+    /**
+     * Creates a new user with the specified credentials and hierarchy level.
+     *
+     * @param username  unique identifier for the user
+     * @param name      full name of the user
+     * @param password  user's authentication credential
+     * @param hierarchy user's position in the system hierarchy
+     * @throws IllegalArgumentException if any parameter is null or empty strings
+     */
+    protected AbstractUser(String username, String name, String password, Hierarchy hierarchy) {
+        setUsername(username);
+        setName(name);
+        setPassword(password);
+        setHierarchy(hierarchy);
+    }
+
+    @Override
+    public String getUsername() {
+        return username;
+    }
+
+    @Override
+    public void setUsername(String username) {
+        if (username == null || username.trim().isEmpty()) {
+            throw new IllegalArgumentException("Username cannot be null or empty");
+        }
+        this.username = username.trim();
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public void setName(String name) {
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Name cannot be null or empty");
+        }
+        this.name = name.trim();
+    }
+
+    @Override
+    public String getPassword() {
+        return password;
+    }
+
+    @Override
+    public void setPassword(String password) {
+        if (password == null || password.trim().isEmpty()) {
+            throw new IllegalArgumentException("Password cannot be null or empty");
+        }
+        this.password = password;
+    }
+
+    @Override
+    public Hierarchy getHierarchy() {
+        return hierarchy;
+    }
+
+    @Override
+    public void setHierarchy(Hierarchy hierarchy) {
+        if (hierarchy == null) {
+            throw new IllegalArgumentException("Hierarchy cannot be null");
+        }
+        this.hierarchy = hierarchy;
+    }
+
+    @Override
+    public int compareTo(User other) {
+        return this.hierarchy.getValue() - other.getHierarchy().getValue();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof User)) return false;
+
+        User other = (User) obj;
+        return Objects.equals(username, other.getUsername()) &&
+                Objects.equals(name, other.getName()) &&
+                Objects.equals(password, other.getPassword()) &&
+                Objects.equals(hierarchy, other.getHierarchy());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(username, name, password, hierarchy);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("User[username='%s', name='%s', hierarchy=%s]",
+                username,
+                name,
+                hierarchy.getDisplayName());
+    }
+}

main/src/main/java/server/structs/implementations/StandardMessage.java

@@ -0,0 +1,46 @@
+package server.structs.implementations;
+
+import server.structs.abstractions.AbstractMessage;
+import server.structs.intfaces.Message;
+import server.structs.intfaces.User;
+
+/**
+ * Standard message implementation for the emergency communication system.
+ * Provides a concrete implementation for direct, broadcast, and group messages.
+ *
+ * Features:
+ * - Direct user-to-user messaging
+ * - Broadcast messaging support
+ * - Multicast group communication
+ * - Emergency notifications
+ * - Timestamp-based ordering
+ *
+ * @author 0x1eo
+ * @since 2024-12-13 03:42:45 UTC
+ * @see Message
+ * @see AbstractMessage
+ * @see User
+ */
+public class StandardMessage extends AbstractMessage {
+
+    /**
+     * Creates a new message in the emergency system.
+     *
+     * @param sender   the user initiating the message
+     * @param receiver the recipient (user, broadcast address, or multicast group)
+     * @param content  the message content
+     * @throws IllegalArgumentException if sender or content is null
+     */
+    public StandardMessage(User sender, Object receiver, String content) {
+        super(sender, receiver, content);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("Message[from=%s, to=%s, content='%s', time=%s]",
+                getSender(),
+                getReceiver(),
+                getMessage(),
+                getTimestamp());
+    }
+}

main/src/main/java/server/structs/implementations/StandardNotification.java

@@ -0,0 +1,44 @@
+package server.structs.implementations;
+
+import server.structs.abstractions.AbstractNotification;
+import server.structs.intfaces.User;
+import server.utils.UserHandler;
+
+/**
+ * Standard notification implementation for the emergency communication system.
+ * Provides a concrete implementation of AbstractNotification for general-purpose
+ * system notifications.
+ *
+ * Features:
+ * - Direct messaging support
+ * - Broadcast capability
+ * - Multicast group messaging
+ * - System alerts and announcements
+ *
+ * @author 0x1eo
+ * @since 2024-12-13 03:41:39 UTC
+ * @see AbstractNotification
+ */
+public class StandardNotification extends AbstractNotification {
+
+    /**
+     * Creates a new standard notification.
+     *
+     * @param sender   the sender's identifier (user, system, or service)
+     * @param receiver the recipient's identifier (user, broadcast, or multicast group)
+     * @param message  the notification content
+     * @throws IllegalArgumentException if any parameter is null
+     */
+    public StandardNotification(Object sender, Object receiver, String message) {
+        super(sender, receiver, message);
+    }
+
+    public String convertToUser(Object obj) {
+        if (obj instanceof String) {
+            // Use your user lookup mechanism
+            return UserHandler.findUser(String.valueOf(obj));
+        }
+        throw new IllegalArgumentException("Cannot convert to User: " + obj);
+    }
+
+}

main/src/main/java/server/structs/implementations/StandardRequest.java

@@ -0,0 +1,17 @@
+package server.structs.implementations;
+
+import server.structs.abstractions.AbstractRequest;
+import server.structs.intfaces.User;
+
+/**
+ * Standard request implementation for the emergency communication system.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ */
+public class StandardRequest extends AbstractRequest {
+
+    public StandardRequest(User sender, String receiver, String content) {
+        super(sender, receiver, content);
+    }
+}

main/src/main/java/server/structs/implementations/StandardUser.java

@@ -0,0 +1,17 @@
+package server.structs.implementations;
+
+import server.structs.abstractions.AbstractUser;
+import shared.enums.Hierarchy;
+
+/**
+ * Standard user implementation for the emergency communication system.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ */
+public class StandardUser extends AbstractUser {
+
+    public StandardUser(String username, String name, String password, Hierarchy hierarchy) {
+        super(username, name, password, hierarchy);
+    }
+}

main/src/main/java/server/structs/intfaces/Message.java

@@ -0,0 +1,15 @@
+package server.structs.intfaces;
+
+/**
+ * Represents a message in the communication system.
+ * Extends the base Notification interface to provide message-specific functionality.
+ * This interface serves as a marker for distinguishing message types from other notifications.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ * @see Notification
+ */
+public interface Message extends Notification {
+    // Marker interface - no additional methods required
+    // Implementation classes should provide message-specific functionality
+}

main/src/main/java/server/structs/intfaces/Notification.java

@@ -0,0 +1,86 @@
+package server.structs.intfaces;
+
+import java.io.Serializable;
+import java.time.Instant;
+
+/**
+ * Represents a notification in the communication system.
+ * Provides methods for managing notification metadata and content.
+ * Implements Serializable for network transmission and Comparable for ordering.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public interface Notification extends Serializable, Comparable<Notification> {
+
+    /**
+     * Gets the sender of the notification.
+     *
+     * @return the sender's identifier
+     */
+    User getSender();
+
+    /**
+     * Sets the sender of the notification.
+     *
+     * @param sender the sender's identifier
+     * @throws IllegalArgumentException if sender is null or empty
+     */
+    void setSender(Object sender);
+
+    /**
+     * Gets the receiver of the notification.
+     *
+     * @return the receiver's identifier
+     */
+    User getReceiver();
+
+    /**
+     * Sets the receiver of the notification.
+     *
+     * @param receiver the receiver's identifier
+     * @throws IllegalArgumentException if receiver is null or empty
+     */
+    void setReceiver(Object receiver);
+
+    /**
+     * Gets the content of the notification.
+     *
+     * @return the notification message content
+     */
+    String getMessage();
+
+    /**
+     * Sets the content of the notification.
+     *
+     * @param message the notification message content
+     * @throws IllegalArgumentException if message is null
+     */
+    void setMessage(String message);
+
+    /**
+     * Gets the timestamp of the notification.
+     *
+     * @return the instant when the notification was created
+     */
+    Instant getTimestamp();
+
+    /**
+     * Sets the timestamp of the notification.
+     *
+     * @param timestamp the instant when the notification was created
+     * @throws IllegalArgumentException if timestamp is null
+     */
+    void setTimestamp(Instant timestamp);
+
+    /**
+     * Provides a default natural ordering for notifications based on timestamp.
+     * 
+     * @param other the notification to compare with
+     * @return negative if this is earlier, zero if same time, positive if later
+     */
+    @Override
+    default int compareTo(Notification other) {
+        return this.getTimestamp().compareTo(other.getTimestamp());
+    }
+}

main/src/main/java/server/structs/intfaces/Request.java

@@ -0,0 +1,29 @@
+package server.structs.intfaces;
+
+/**
+ * Represents a request in the communication system.
+ * Extends the Notification interface to add request-specific functionality.
+ * A request is a special type of notification that includes an author (requesting user).
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ * @see Notification
+ * @see User
+ */
+public interface Request extends Notification {
+
+    /**
+     * Gets the author (requesting user) of this request.
+     *
+     * @return the user who authored this request
+     */
+    User getTruster();
+
+    /**
+     * Sets the author (requesting user) of this request.
+     *
+     * @param author the user who authored this request
+     * @throws IllegalArgumentException if author is null
+     */
+    void setTruster(User author);
+}

main/src/main/java/server/structs/intfaces/User.java

@@ -0,0 +1,101 @@
+package server.structs.intfaces;
+
+import java.io.Serializable;
+
+import shared.enums.Hierarchy;
+
+/**
+ * Represents a user in the system with their credentials and permissions.
+ * Implements Serializable for network transmission and Comparable for user ordering.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public interface User extends Serializable, Comparable<User> {
+
+    /**
+     * Gets the user's unique username.
+     *
+     * @return the username
+     */
+    String getUsername();
+
+    /**
+     * Sets the user's username.
+     *
+     * @param username the username to set
+     * @throws IllegalArgumentException if username is null or empty
+     */
+    void setUsername(String username);  // Fixed method name from setUserName
+
+    /**
+     * Gets the user's password (hashed).
+     *
+     * @return the hashed password
+     */
+    String getPassword();
+
+    /**
+     * Sets the user's password.
+     * Implementation should ensure the password is properly hashed before storage.
+     *
+     * @param password the password to set
+     * @throws IllegalArgumentException if password is null or empty
+     */
+    void setPassword(String password);
+
+    /**
+     * Gets the user's display name.
+     *
+     * @return the user's full name
+     */
+    String getName();
+
+    /**
+     * Sets the user's display name.
+     *
+     * @param name the name to set
+     * @throws IllegalArgumentException if name is null or empty
+     */
+    void setName(String name);
+
+    /**
+     * Gets the user's hierarchy level in the system.
+     *
+     * @return the user's hierarchy level
+     */
+    Hierarchy getHierarchy();
+
+    /**
+     * Sets the user's hierarchy level.
+     *
+     * @param hierarchy the hierarchy level to set
+     * @throws IllegalArgumentException if hierarchy is null
+     */
+    void setHierarchy(Hierarchy hierarchy);
+
+    /**
+     * Provides a default natural ordering for users based on username.
+     * 
+     * @param other the user to compare with
+     * @return negative if this username comes before, zero if equal, positive if after
+     */
+    @Override
+    default int compareTo(User other) {
+        return this.getUsername().compareToIgnoreCase(other.getUsername());
+    }
+
+    /**
+     * Checks if the user has at least the specified hierarchy level.
+     *
+     * @param minimumHierarchy the minimum required hierarchy level
+     * @return true if user's hierarchy is at least the specified level
+     * @throws IllegalArgumentException if minimumHierarchy is null
+     */
+    default boolean hasMinimumHierarchy(Hierarchy minimumHierarchy) {
+        if (minimumHierarchy == null) {
+            throw new IllegalArgumentException("Minimum hierarchy cannot be null");
+        }
+        return this.getHierarchy().ordinal() >= minimumHierarchy.ordinal();
+    }
+}

main/src/main/java/server/utils/InputCommandRouter.java

@@ -0,0 +1,90 @@
+package server.utils;
+
+import java.net.Socket;
+import java.util.logging.Logger;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import server.structs.SystemStateManager;
+import server.structs.intfaces.User;
+import shared.enums.ConnType;
+
+/**
+ * This class represents the protocol used for processing input in the server.
+ */
+public class InputCommandRouter {
+    private static final Logger logger = Logger.getLogger(InputCommandRouter.class.getName());
+    /**
+     * Processes the input based on the given connection type, socket packet, and input string.
+     *
+     * @param connType The type of connection (DIRECT or INDIRECT).
+     * @param socketPacket The socket packet object.
+     * @param input The input string to be processed.
+     * @return The response as a JSON string.
+     */
+    public static String processInput(ConnType connType, Object socketPacket, String input) {
+        JSONObject response = new JSONObject();
+        try {
+            JSONObject json = new JSONObject(input);
+            if (!json.has("command")) {
+                response.put("response", "Invalid command!");
+                return response.toString();
+            }
+
+            // Register the user's socket if it is not already registered
+            Socket socket;
+            if (connType == ConnType.UNICAST) {
+                if (json.has("username") || json.has("from")) {
+                    User User = null;
+                    if (json.has("username")) {
+                        User = SystemStateManager.getUser(json.getString("username"));
+                    }
+                    if (json.has("from")) {
+                        User = SystemStateManager.getUser(json.getString("from"));
+                    }
+                    if (User != null) {
+                        if (socketPacket instanceof Socket) {
+                            socket = (Socket) socketPacket;
+                            if (socket != SystemStateManager.getUserSocket(User)) {
+                                SystemStateManager.addUserSocket(User, socket);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Process the input based on the command
+            switch (json.getString("command")) {
+                case "register":
+                    if (connType != ConnType.UNICAST) {
+                        return null;
+                    }
+                    socket = (Socket) socketPacket;
+                    return UserHandler.register(json, socketPacket);
+                case "login":
+                    if (connType != ConnType.UNICAST) {
+                        return null;
+                    }
+                    socket = (Socket) socketPacket;
+                    return UserHandler.login(json, socketPacket);
+                case "message":
+                    MessageProtocolHandler.receiveMessage(connType, json);
+                    return null;
+                case "request":
+                    MessageProtocolHandler.receiveRequest(connType, json, socketPacket);
+                    return null;
+                case "joinGroup":
+                    UserHandler.joinGroup(json);
+                    return null;
+                default:
+                    logger.severe("Invalid command received! " + input);
+                    return null;
+            }
+
+        } catch (JSONException e) {
+            logger.severe("Invalid JSON received! " + e.getMessage());
+            return null;
+        }
+    }
+}

main/src/main/java/server/utils/MessageProtocolHandler.java

@@ -0,0 +1,260 @@
+package server.utils;
+
+import java.text.SimpleDateFormat;
+import java.util.Collection;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.logging.Logger;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import server.structs.SystemStateManager;
+import server.structs.implementations.StandardMessage;
+import server.structs.implementations.StandardRequest;
+import server.structs.intfaces.Notification;
+import server.structs.intfaces.Message;
+import server.structs.intfaces.Request;
+import server.structs.intfaces.User;
+import server.handlers.AcceptRequestHandler;
+import shared.enums.ConnType;
+
+public class MessageProtocolHandler {
+    private static final Logger logger = Logger.getLogger(MessageProtocolHandler.class.getName());
+    private static final ExecutorService executorService = Executors.newFixedThreadPool(50);
+
+    /**
+     * Returns the ExecutorService used by the EventsHandler.
+     *
+     * @return the ExecutorService used by the EventsHandler
+     */
+    public static ExecutorService getExecutorService() {
+        return executorService;
+    }
+
+    /**
+     * Converts an event to a JSON object.
+     *
+     * @param notification The event to convert.
+     * @return The JSON object representation of the event.
+     */
+    public static <N extends Notification> JSONObject notificationToJson(N notification) throws JSONException {
+        JSONObject json = new JSONObject();
+        json.put("from", notification.getSender());
+        Object receiver = notification.getReceiver();
+        if (receiver instanceof User) {
+            json.put("to", ((User) receiver).getUsername());
+        } else if (receiver instanceof String) {
+            String receiverString = (String) receiver;
+            if (receiverString.equals("broadcast")) {
+                json.put("to", "broadcast");
+            } else if (receiverString.matches(
+                    "^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$")) {
+                json.put("to", receiverString);
+            }
+        } else {
+            logger.severe("Invalid receiver type!");
+        }
+        json.put("content", notification.getMessage());
+        SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm");
+        json.put("date", sdf.format(notification.getTimestamp()));
+        if (notification instanceof Message) {
+            json.put("command", "message");
+            return json;
+        } else if (notification instanceof Request) {
+            json.put("command", "request");
+            Request request = (Request) notification;
+            if (request.getTruster() != null) {
+                json.put("accepter", request.getTruster().getUsername());
+            } else {
+                json.put("accepter", "");
+            }
+            return json;
+        }
+        throw new JSONException("Invalid event type");
+    }
+
+
+    /**
+     * Converts a collection of events to a JSON array.
+     *
+     * @param notifications The collection of events to convert.
+     * @return The JSON array representation of the events.
+     * @throws JSONException If an error occurs while converting the events to JSON.
+     */
+    public static JSONArray notificationsToJson(Collection<? extends Notification> notifications) throws JSONException {
+        JSONArray jsonArray = new JSONArray();
+        for (Notification notification : notifications) {
+            jsonArray.put(notificationToJson(notification));
+        }
+        return jsonArray;
+    }
+
+    /**
+     * Converts a JSON object to a message.
+     *
+     * @param json The JSON object to convert.
+     * @return The message representation of the JSON object.
+     */
+    public static Message messageFromJson(JSONObject json) {
+        try {
+            if (!json.has("from") || !json.has("to") || !json.has("content")) {
+                logger.severe("Invalid message received! (field missing)");
+                return null;
+            }
+            if (json.getString("from").equals("server")) {
+                return null;
+            }
+            User from = SystemStateManager.getUser(json.getString("from"));
+            if (from == null) {
+                logger.severe("Invalid message received! (User from)");
+                return null;
+            }
+            String to = json.getString("to");
+            String content = json.getString("content");
+            Message message = new StandardMessage(from, null, content);
+            if (to.equals("broadcast")) {
+                message.setReceiver(to);
+            } else if (to.matches(
+                    "^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$")) {
+                message.setReceiver(to);
+            } else {
+                message.setReceiver(SystemStateManager.getUser(to));
+            }
+            if (message.getReceiver() == null) {
+                logger.severe("Invalid message received! (User to)");
+                return null;
+            }
+            return message;
+        } catch (JSONException ignored) {
+            logger.severe("Invalid message received! (JSONException)");
+            return null;
+        }
+    }
+
+    /**
+     * Converts a JSON object to a request.
+     *
+     * @param json The JSON object to convert.
+     * @return The request representation of the JSON object.
+     */
+    public static Request requestFromJson(JSONObject json) {
+        try {
+            if (!json.has("from") || !json.has("to") || !json.has("content")) {
+                logger.severe("Invalid request received! (field missing)");
+                return null;
+            }
+            User from = SystemStateManager.getUser(json.getString("from"));
+            if (from == null) {
+                logger.severe("Invalid request received! (User from)");
+                return null;
+            }
+            String to = json.getString("to");
+            String content = json.getString("content");
+            Request request = new StandardRequest(from, null, content);
+            if (to.equals("broadcast")) {
+                request.setReceiver(to);
+            } else if (to.matches(
+                    "^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$")) {
+                request.setReceiver(to);
+            } else {
+                request.setReceiver(SystemStateManager.getUser(to));
+            }
+            if (request.getReceiver() == null) {
+                logger.severe("Invalid request received! (User to)");
+                return null;
+            }
+            return request;
+        } catch (JSONException ignored) {
+            logger.severe("Invalid request received! (JSONException)");
+            return null;
+        }
+    }
+
+    /// ! Protocol methods
+
+    /**
+     * Receives a message and processes it based on the connection type and the message content.
+     *
+     * @param connType the type of connection (DIRECT or BROADCAST)
+     * @param json the JSON object containing the message data
+     * @return always returns null
+     */
+    public static String receiveMessage(ConnType connType, JSONObject json) {
+        Message message = messageFromJson(json);
+        if (message != null) {
+            Object Receiver = message.getReceiver();
+            if (Receiver instanceof User) {
+                SystemStateManager.addUserNotification((User) message.getReceiver(), message);
+            } else if (Receiver instanceof String) {
+                String receiverString = (String) Receiver;
+                if (receiverString.equals("broadcast")) {
+                    Collection<User> users = SystemStateManager.getUsers();
+                    for (User user : users) {
+                        SystemStateManager.addUserNotification(user, message);
+                    }
+                } else if (receiverString.matches(
+                        "^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$")) {
+                    Collection<User> users = SystemStateManager.getUsersFromGroup(receiverString);
+                    for (User user : users) {
+                        SystemStateManager.addUserNotification(user, message);
+                    }
+                } else {
+                    User user = SystemStateManager.getUser(receiverString);
+                    if (user != null) {
+                        SystemStateManager.addUserNotification(user, message);
+                    }
+                }
+            }
+            SystemStateManager.addUserNotification(message.getSender(), message);
+            if (connType == ConnType.UNICAST) {
+                SystemStateManager.addNotificationToDeliver(message);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Receives a request and processes it based on the connection type, JSON data, and socket packet.
+     *
+     * @param connType The type of connection (DIRECT or INDIRECT).
+     * @param json The JSON object containing the request data.
+     * @param socketPacket The socket packet associated with the request.
+     * @return The response string.
+     */
+    public static String receiveRequest(ConnType connType, JSONObject json, Object socketPacket) {
+        Request request = requestFromJson(json);
+        if (request != null) {
+            Object Receiver = request.getReceiver();
+            if (Receiver instanceof User) {
+                SystemStateManager.addUserNotification(request.getReceiver(), request);
+            } else if (Receiver instanceof String) {
+                String receiverString = (String) Receiver;
+                if (receiverString.equals("broadcast")) {
+                    Collection<User> users = SystemStateManager.getUsers();
+                    for (User user : users) {
+                        SystemStateManager.addUserNotification(user, request);
+                    }
+                } else if (receiverString.matches(
+                        "^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$")) {
+                    Collection<User> users = SystemStateManager.getUsersFromGroup(receiverString);
+                    for (User user : users) {
+                        SystemStateManager.addUserNotification(user, request);
+                    }
+                } else {
+                    User user = SystemStateManager.getUser(receiverString);
+                    if (user != null) {
+                        SystemStateManager.addUserNotification(user, request);
+                    }
+                }
+            }
+            SystemStateManager.addUserNotification(request.getSender(), request);
+            if (connType == ConnType.UNICAST) {
+                SystemStateManager.addNotificationToDeliver(request);
+            }
+            executorService.execute(new AcceptRequestHandler(connType, request));
+        }
+        return null;
+    }
+}

main/src/main/java/server/utils/UserHandler.java

@@ -0,0 +1,193 @@
+package server.utils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import server.Server;
+import server.handlers.MessageHistoryHandler;
+import server.structs.SystemStateManager;
+import server.structs.intfaces.User;
+import server.structs.implementations.StandardUser;  // New concrete implementation
+import shared.enums.Hierarchy;
+
+/**
+ * Handles user registration, authentication, and communication in the emergency system.
+ * Manages user sessions and group memberships.
+ *
+ * @author 0x1eo
+ * @since 2024-12-13
+ */
+public class UserHandler {
+    private static final Logger logger = Logger.getLogger(UserHandler.class.getName());
+    private static final String MULTICAST_GROUP_PATTERN =
+            "^(22[4-9]|23[0-9]|2[4-9][0-9]|[3-9][0-9]{2}|[12][0-9]{3})"
+                    + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+                    + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+                    + "\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$";
+
+    // Prevent instantiation
+    private UserHandler() {}
+
+    /**
+     * Registers a new user in the system.
+     *
+     * @param json The registration details
+     * @param socketPacket The connection socket
+     * @return JSON response indicating success or failure
+     * @throws JSONException If registration data is malformed
+     */
+    public static String register(JSONObject json, Object socketPacket) throws JSONException {
+        try {
+            String username = json.getString("username");
+            if (SystemStateManager.getUser(username) != null) {
+                logger.info("Registration failed: User already exists - " + username);
+                return createErrorResponse("User already exists!");
+            }
+
+            User user = createUser(json);
+            Socket socket = (Socket) socketPacket;
+
+            SystemStateManager.addUser(user);
+            SystemStateManager.addUserSocket(user, socket);
+
+            return createSuccessResponse();
+        } catch (IllegalArgumentException e) {
+            logger.log(Level.WARNING, "Registration failed: Invalid role", e);
+            return createErrorResponse("Invalid role!");
+        } catch (Exception e) {
+            logger.log(Level.SEVERE, "Registration failed: Unexpected error", e);
+            return e.getMessage();
+        }
+    }
+
+    /**
+     * Creates a new user instance from JSON data.
+     */
+    private static User createUser(JSONObject json) throws JSONException {
+        return new StandardUser(
+                json.getString("username"),
+                json.getString("name"),
+                json.getString("password"),
+                Hierarchy.valueOf(json.getString("role").toUpperCase())
+        );
+    }
+
+    /**
+     * Authenticates a user and establishes their session.
+     */
+    public static String login(JSONObject json, Object socketPacket) throws JSONException {
+        User user = SystemStateManager.getUser(json.getString("username"));
+
+        if (user == null) {
+            logger.info("Login failed: Invalid username");
+            return createErrorResponse("Invalid username!");
+        }
+
+        if (!user.getPassword().equals(json.getString("password"))) {
+            logger.info("Login failed: Invalid password for user " + user.getUsername());
+            return createErrorResponse("Invalid password!");
+        }
+
+        establishUserSession(user, (Socket) socketPacket);
+        return createSuccessResponse();
+    }
+
+    /**
+     * Sets up user session and starts message history handler.
+     */
+    private static void establishUserSession(User user, Socket socket) {
+        SystemStateManager.addUserSocket(user, socket);
+        new Thread(new MessageHistoryHandler(user)).start();
+    }
+
+    /**
+     * Sends data to a user through their socket connection.
+     */
+    public static void sendSomething(User user, String data) throws IOException {
+        try (Socket newSocket = createUserSocket(user);
+             PrintWriter out = new PrintWriter(newSocket.getOutputStream(), true)) {
+            out.println(data);
+        }
+    }
+
+    /**
+     * Sends data and waits for a response.
+     */
+    public static String sendAndReceiveSomething(User user, String data) throws IOException {
+        try (Socket newSocket = createUserSocket(user);
+             PrintWriter out = new PrintWriter(newSocket.getOutputStream(), true);
+             BufferedReader in = new BufferedReader(new InputStreamReader(newSocket.getInputStream()))) {
+            out.println(data);
+            return in.readLine();
+        }
+    }
+
+    private static Socket createUserSocket(User user) throws IOException {
+        Socket userSocket = SystemStateManager.getUserSocket(user);
+        return new Socket(userSocket.getInetAddress(), Server.USER_PORT);
+    }
+
+    /**
+     * Adds a user to a multicast group.
+     */
+    public static String joinGroup(JSONObject json) throws JSONException {
+        if (!isValidGroupRequest(json)) {
+            return null;
+        }
+
+        User user = SystemStateManager.getUser(json.getString("username"));
+        if (user == null) {
+            logger.info("Group join failed: Invalid username");
+            return null;
+        }
+
+        try {
+            String group = json.getString("group");
+            SystemStateManager.getMulticastSocket().joinGroup(InetAddress.getByName(group));
+            SystemStateManager.addUserToGroup(group, user);
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Failed to join multicast group", e);
+        }
+        return null;
+    }
+
+    private static boolean isValidGroupRequest(JSONObject json) {
+        if (!json.has("group") || !json.has("username")) {
+            logger.info("Group join failed: Missing required fields");
+            return false;
+        }
+
+        String group = json.getString("group");
+        if (!group.matches(MULTICAST_GROUP_PATTERN)) {
+            logger.info("Group join failed: Invalid group address - " + group);
+            return false;
+        }
+
+        return true;
+    }
+
+    private static String createSuccessResponse() {
+        return new JSONObject().put("response", "OK").toString();
+    }
+
+    private static String createErrorResponse(String message) {
+        return new JSONObject().put("response", message).toString();
+    }
+
+    public static String findUser(String username) {
+        User user = SystemStateManager.getUser(username);
+        if (user == null) {
+            return null;
+        }
+        return user.getUsername();
+    }
+}

main/src/main/java/shared/enums/ConnType.java

@@ -0,0 +1,72 @@
+package shared.enums;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * Represents different types of network connections used in the application.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public enum ConnType {
+    UNICAST("Unicast", "Point-to-point connection between two nodes"),
+    MULTICAST("Multicast", "One-to-many connection to a specific group of nodes"),
+    BROADCAST("Broadcast", "One-to-all connection reaching all nodes in the network");
+
+    private final String displayName;
+    private final String description;
+
+    ConnType(String displayName, String description) {
+        this.displayName = displayName;
+        this.description = description;
+    }
+
+    /**
+     * Gets the user-friendly display name of the connection type.
+     *
+     * @return the display name
+     */
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    /**
+     * Gets the description of the connection type.
+     *
+     * @return the description
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * Safely converts a string to a ConnType.
+     *
+     * @param value the string value to convert
+     * @return an Optional containing the ConnType if valid, empty Optional otherwise
+     */
+    public static Optional<ConnType> fromString(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Arrays.stream(values())
+                .filter(connType -> connType.name().equalsIgnoreCase(value.trim()))
+                .findFirst();
+    }
+
+    /**
+     * Checks if the connection type is suitable for group communication.
+     *
+     * @return true if the connection type supports group communication
+     */
+    public boolean isGroupCapable() {
+        return this == MULTICAST || this == BROADCAST;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s (%s)", displayName, description);
+    }
+}

main/src/main/java/shared/enums/Hierarchy.java

@@ -0,0 +1,108 @@
+package shared.enums;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * Represents the priority levels in the system's hierarchy.
+ * Used for tasks and user permissions.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public enum Hierarchy {
+    LOW(0, "Low Priority"),
+    MEDIUM(1, "Medium Priority"),
+    HIGH(2, "High Priority");
+
+    private final int value;
+    private final String displayName;
+
+    Hierarchy(int value, String displayName) {
+        this.value = value;
+        this.displayName = displayName;
+    }
+
+    /**
+     * Gets the numeric value associated with this hierarchy level.
+     *
+     * @return the numeric value of the hierarchy level
+     */
+    public int getValue() {
+        return value;
+    }
+
+    /**
+     * Gets the display name of this hierarchy level.
+     *
+     * @return the user-friendly name of the hierarchy level
+     */
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    /**
+     * Finds a Hierarchy enum by its numeric value.
+     *
+     * @param value the numeric value to look up
+     * @return an Optional containing the Hierarchy if found, empty Optional otherwise
+     */
+    public static Optional<Hierarchy> fromValue(int value) {
+        return Arrays.stream(values())
+                .filter(h -> h.value == value)
+                .findFirst();
+    }
+
+    /**
+     * Finds a Hierarchy enum by its name (case-insensitive).
+     *
+     * @param name the name to look up
+     * @return an Optional containing the Hierarchy if found, empty Optional otherwise
+     */
+    public static Optional<Hierarchy> fromString(String name) {
+        if (name == null || name.trim().isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Arrays.stream(values())
+                .filter(h -> h.name().equalsIgnoreCase(name.trim()))
+                .findFirst();
+    }
+
+    /**
+     * Gets all hierarchy values as strings.
+     *
+     * @return array of hierarchy names
+     */
+    public static String[] getAllNames() {
+        return Arrays.stream(values())
+                .map(Hierarchy::name)
+                .toArray(String[]::new);
+    }
+
+    /**
+     * Gets all hierarchy display names.
+     *
+     * @return array of user-friendly hierarchy names
+     */
+    public static String[] getAllDisplayNames() {
+        return Arrays.stream(values())
+                .map(Hierarchy::getDisplayName)
+                .toArray(String[]::new);
+    }
+
+    /**
+     * Compares this hierarchy level with another.
+     *
+     * @param other the hierarchy level to compare with
+     * @return true if this level is higher than the other
+     */
+    public boolean isHigherThan(Hierarchy other) {
+        return this.value > other.value;
+    }
+
+    @Override
+    public String toString() {
+        return displayName;
+    }
+}

main/src/main/java/shared/enums/RecvType.java

@@ -0,0 +1,90 @@
+package shared.enums;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * Represents different types of message receivers in the communication system.
+ *
+ * @author 0x1eo
+ * @since 2024-12-12
+ */
+public enum RecvType {
+    USER("Single User", "Direct message to a specific user"),
+    GROUP("Group", "Message to a defined group of users"),
+    BROADCAST("Broadcast", "Message to all users in the network");
+
+    private final String displayName;
+    private final String description;
+
+    RecvType(String displayName, String description) {
+        this.displayName = displayName;
+        this.description = description;
+    }
+
+    /**
+     * Gets the user-friendly display name of the receiver type.
+     *
+     * @return the display name
+     */
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    /**
+     * Gets the description of the receiver type.
+     *
+     * @return the description
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * Determines if this receiver type supports multiple recipients.
+     *
+     * @return true if the receiver type supports multiple recipients
+     */
+    public boolean isMultiReceiver() {
+        return this == GROUP || this == BROADCAST;
+    }
+
+    /**
+     * Safely converts a string to a RecvType.
+     *
+     * @param value the string value to convert
+     * @return an Optional containing the RecvType if valid, empty Optional otherwise
+     */
+    public static Optional<RecvType> fromString(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Arrays.stream(values())
+                .filter(type -> type.name().equalsIgnoreCase(value.trim()))
+                .findFirst();
+    }
+
+    /**
+     * Gets the appropriate receiver type for a given number of recipients.
+     *
+     * @param recipientCount the number of recipients
+     * @return the appropriate receiver type
+     */
+    public static RecvType forRecipientCount(int recipientCount) {
+        if (recipientCount <= 0) {
+            throw new IllegalArgumentException("Recipient count must be positive");
+        }
+
+        return switch (recipientCount) {
+            case 1 -> USER;
+            case Integer.MAX_VALUE -> BROADCAST;
+            default -> GROUP;
+        };
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s (%s)", displayName, description);
+    }
+}