[NP] Администрација на чет-систем

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;

class NoSuchRoomException extends Exception {
    public NoSuchRoomException(String roomName) {
        super(roomName);
    }
}

class NoSuchUserException extends Exception {
    public NoSuchUserException(String userName) {
        super(userName);
    }
}

class ChatRoom {
    private String name;
    private TreeSet<String> usernamesTreeSet;

    public ChatRoom(String name) {
        this.name = name;
        usernamesTreeSet = new TreeSet<>();
    }

    public void addUser(String username) {
        usernamesTreeSet.add(username);
    }

    public void removeUser(String username) {
        usernamesTreeSet.remove(username);
    }

    public boolean hasUser(String username) {
        return usernamesTreeSet.contains(username);
    }

    public int numUsers() {
        return usernamesTreeSet.size();
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append(name + System.lineSeparator());
        if (this.numUsers() == 0) {
            sb.append("EMPTY\n");
        } else {
            for (String user : usernamesTreeSet) {
                sb.append(user + System.lineSeparator());
            }
        }
        return sb.toString();
    }
}

class ChatSystem {
    private TreeMap<String, ChatRoom> chatRoomsTreeMap;
    private HashSet<String> userNamesHashSet;

    public ChatSystem() {
        this.chatRoomsTreeMap = new TreeMap<>();
        this.userNamesHashSet = new HashSet<>();
    }

    public void addRoom(String roomName) {
        chatRoomsTreeMap.put(roomName, new ChatRoom(roomName));
    }

    public void removeRoom(String roomName) {
        chatRoomsTreeMap.remove(roomName);
    }

    public ChatRoom getRoom(String roomName) throws NoSuchRoomException {
        if (chatRoomsTreeMap.get(roomName) == null) {
            throw new NoSuchRoomException(roomName);
        }
        return chatRoomsTreeMap.get(roomName);
    }

    public void register(String userName) {
        userNamesHashSet.add(userName);
        /* Begin Case */
        if (chatRoomsTreeMap.size() == 0) return;

        /* In-use Case */
        ChatRoom leastPopulatedRoom = chatRoomsTreeMap.values().stream()
                .min(Comparator.comparingInt(ChatRoom::numUsers))
                .orElse(null);
        if (leastPopulatedRoom == null) return;
        leastPopulatedRoom.addUser(userName);
    }

    private boolean validateRoom(String roomName) {
        return chatRoomsTreeMap.containsKey(roomName);
    }

    private boolean validateUser(String userName) {
        return userNamesHashSet.contains(userName);
    }

    private void validateUserAndRoom(String userName, String roomName) throws NoSuchRoomException, NoSuchUserException {
        if (!validateRoom(roomName)) throw new NoSuchRoomException(roomName);
        if (!validateUser(userName)) throw new NoSuchUserException(userName);
    }

    public void joinRoom(String userName, String roomName) throws NoSuchRoomException, NoSuchUserException {
        validateUserAndRoom(userName, roomName);
        chatRoomsTreeMap.get(roomName).addUser(userName);
    }

    public void leaveRoom(String userName, String roomName) throws NoSuchRoomException, NoSuchUserException {
        validateUserAndRoom(userName, roomName);
        chatRoomsTreeMap.get(roomName).removeUser(userName);
    }

    public void registerAndJoin(String userName, String roomName) throws NoSuchRoomException, NoSuchUserException {
        userNamesHashSet.add(userName);
        joinRoom(userName, roomName);
    }

    public void followFriend(String userName, String friendUserName) throws NoSuchUserException {
        if (!validateUser(userName)) throw new NoSuchUserException(userName);

        chatRoomsTreeMap.values().stream()
                .forEach(chatRoom -> {
                            if (chatRoom.hasUser(friendUserName)) {
                                chatRoom.addUser(userName);
                            }
                        }
                );
    }
}

/*Како наједноставно би ги зачувале информациите за тоа кој корисник е член на кои соби?
Оваа информација ќе ни треба да ја добиеме брзо за да ја искористиме во followFriend функцијата.*/

public class ChatSystemTest {

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, NoSuchRoomException {
        Scanner jin = new Scanner(System.in);
        int k = jin.nextInt();
        if (k == 0) {
            ChatRoom cr = new ChatRoom(jin.next());
            int n = jin.nextInt();
            for (int i = 0; i < n; ++i) {
                k = jin.nextInt();
                if (k == 0) cr.addUser(jin.next());
                if (k == 1) cr.removeUser(jin.next());
                if (k == 2) System.out.println(cr.hasUser(jin.next()));
            }
            System.out.println("");
            System.out.println(cr.toString());
            n = jin.nextInt();
            if (n == 0) return;
            ChatRoom cr2 = new ChatRoom(jin.next());
            for (int i = 0; i < n; ++i) {
                k = jin.nextInt();
                if (k == 0) cr2.addUser(jin.next());
                if (k == 1) cr2.removeUser(jin.next());
                if (k == 2) cr2.hasUser(jin.next());
            }
            System.out.println(cr2.toString());
        }
        if (k == 1) {
            ChatSystem cs = new ChatSystem();
            Method mts[] = cs.getClass().getMethods();
            while (true) {
                String cmd = jin.next();
                if (cmd.equals("stop")) break;
                if (cmd.equals("print")) {
                    System.out.println(cs.getRoom(jin.next()) + "\n");
                    continue;
                }
                for (Method m : mts) {
                    if (m.getName().equals(cmd)) {
                        String params[] = new String[m.getParameterTypes().length];
                        for (int i = 0; i < params.length; ++i) params[i] = jin.next();
                        m.invoke(cs, params);
                    }
                }
            }
        }
    }

}