Server/Server/src/test/java/uulm/teamname/marvelous/server/netconnector/UserManagerTest.java

package uulm.teamname.marvelous.server.netconnector;

import org.java_websocket.WebSocket;
import org.java_websocket.handshake.ClientHandshake;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import uulm.teamname.marvelous.gamelibrary.messages.ParticipantType;
import uulm.teamname.marvelous.gamelibrary.messages.client.*;
import uulm.teamname.marvelous.server.lobbymanager.Participant;

import java.lang.reflect.InvocationTargetException;

import static org.mockito.Mockito.*;
import static org.assertj.core.api.Assertions.*;

class UserManagerTest {

    UserManager manager;

    Client client1, client2;
    WebSocket socket1, socket2;
    SUID suid1, suid2;

    @BeforeEach
    void beforeEach()
            throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        socket1 = mock(WebSocket.class);
        client1 = spy(new Client(socket1));
        suid1 = new SUID("name1", "devID1");
        when(client1.getId()).thenReturn(suid1);
        when(client1.getSocket()).thenReturn(socket1);

        socket2 = mock(WebSocket.class);
        client2 = spy(new Client(socket2));
        suid2 = new SUID("name2", "devID2");
        when(client2.getId()).thenReturn(suid2);
        when(client2.getSocket()).thenReturn(socket2);

        var c = UserManager.class.getDeclaredConstructor();
        c.setAccessible(true);
        manager = spy(c.newInstance());
    }

    @Test
    void userIsConnectedTest() {
        assertThat(manager.getUserCount()).isEqualTo(0);
        assertThat(manager.containsConnection(socket1)).isFalse();
        manager.connectUser(socket1);
        assertThat(manager.getUserCount()).isEqualTo(1);
        assertThat(manager.containsConnection(socket1)).isTrue();

        verify(socket1, never()).send(any(String.class));
    }

    @Test
    void helloServerMessagesGetAssignedProperly() {
        manager.messageReceived(
                socket1,
                "{\"messageType\":\"HELLO_SERVER\",\"name\":\"SomeAwesomeName\",\"deviceID\":\"YAY\"}");

        // TODO: test this
    }

//    @Test
//    void handshakeGetsCompletedProperlyTest() {
//        // manager.connectUser(connection, handshake);
//
//        manager.getNewUsers().add(connection);
//        // assertThat(manager.getUserCount()).isEqualTo(1);
//        assertThat(manager.getNewUsers()).containsOnly(connection);
//        assertThat(manager.getReadyToConnect()).isEmpty();
//
//        var message = new HelloServerMessage();
//        message.name = "Some Awesome Name";
//        message.deviceID = "Some Interesting ID";
//
//        manager.handshake(connection, message);
//
//        assertThat(manager.getUserCount()).isEqualTo(1);
//        assertThat(manager.getNewUsers()).isEmpty();
//        assertThat(manager.getReadyToConnect()).containsOnlyKeys(connection);
//    }
//
//    @Test
//    void reconnectMessagesGetAssignedProperly() {
//        manager.messageReceived(
//                connection,
//                "{\"messageType\":\"RECONNECT\",\"reconnect\":\"TRUE\"}");
//
//        verify(manager).reconnectClient(
//                eq(connection),
//                any(ReconnectMessage.class));
//    }
//
//    @Test
//    void reconnectWorksProperly() {
//        manager.getActiveParticipants().put(clientID, participant);
//        manager.getReadyToReconnect().put(connection, clientID);
//
//        assertThat(manager.getInGame()).isEmpty();
//
//        var message = new ReconnectMessage();
//        message.reconnect = true;
//
//        manager.reconnectClient(connection, message);
//
//        assertThat(manager.getReadyToReconnect()).isEmpty();
//
//        assertThat(manager.getInGame()).containsOnlyKeys(connection);
//        assertThat(manager.getInGame().get(connection)).isEqualTo(participant);
//
//        // verify(participant).setConnection(connection);
//    }






    /*
    UserManager manager;
    WebSocket connection;
    SUID clientID;
    Participant participant;
    ClientHandshake handshake;

    @BeforeEach
    void beforeEach()
            throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        connection = mock(WebSocket.class);

        var constructor = UserManager.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        manager = spy(constructor.newInstance());

        handshake = mock(ClientHandshake.class);
        when(handshake.getResourceDescriptor()).thenReturn("/someDescriptor");

        clientID = new SUID("Awesome Name", "Awesome deviceID");

        participant = spy(new Participant(connection, ParticipantType.PlayerOne, "Awesome Name"));
    }

    @Test
    void userIsConnectedTest() {
        assertThat(manager.getUserCount()).isEqualTo(0);
        assertThat(manager.getNewUsers()).doesNotContain(connection);
        manager.connectUser(connection);
        assertThat(manager.getUserCount()).isEqualTo(1);
        assertThat(manager.isUserConnected(connection)).isTrue();
        assertThat(manager.getNewUsers()).containsOnly(connection);
    }

    @Test
    void helloServerMessagesGetAssignedProperly() {
        manager.messageReceived(
                connection,
                "{\"messageType\":\"HELLO_SERVER\",\"name\":\"SomeAwesomeName\",\"deviceID\":\"YAY\"}");

        verify(manager).handshake(
                eq(connection),
                any(HelloServerMessage.class));
    }

    @Test
    void handshakeGetsCompletedProperlyTest() {
        // manager.connectUser(connection, handshake);

        manager.getNewUsers().add(connection);
        // assertThat(manager.getUserCount()).isEqualTo(1);
        assertThat(manager.getNewUsers()).containsOnly(connection);
        assertThat(manager.getReadyToConnect()).isEmpty();

        var message = new HelloServerMessage();
        message.name = "Some Awesome Name";
        message.deviceID = "Some Interesting ID";

        manager.handshake(connection, message);

        assertThat(manager.getUserCount()).isEqualTo(1);
        assertThat(manager.getNewUsers()).isEmpty();
        assertThat(manager.getReadyToConnect()).containsOnlyKeys(connection);
    }

    @Test
    void reconnectMessagesGetAssignedProperly() {
        manager.messageReceived(
                connection,
                "{\"messageType\":\"RECONNECT\",\"reconnect\":\"TRUE\"}");

        verify(manager).reconnectClient(
                eq(connection),
                any(ReconnectMessage.class));
    }

    @Test
    void reconnectWorksProperly() {
        manager.getActiveParticipants().put(clientID, participant);
        manager.getReadyToReconnect().put(connection, clientID);

        assertThat(manager.getInGame()).isEmpty();

        var message = new ReconnectMessage();
        message.reconnect = true;

        manager.reconnectClient(connection, message);

        assertThat(manager.getReadyToReconnect()).isEmpty();

        assertThat(manager.getInGame()).containsOnlyKeys(connection);
        assertThat(manager.getInGame().get(connection)).isEqualTo(participant);

        // verify(participant).setConnection(connection); // TODO: fix this
    }

    @Test
    void notReconnectTransfersPlayerToReadyToConnect() {
        manager.getReadyToReconnect().put(connection, clientID);

        assertThat(manager.getReadyToReconnect()).containsOnlyKeys(connection);
        assertThat(manager.getReadyToConnect()).isEmpty();
        assertThat(manager.getInGame()).isEmpty();

        var message = new ReconnectMessage();
        message.reconnect = false;

        manager.reconnectClient(connection, message);

        assertThat(manager.getReadyToReconnect()).isEmpty();
        assertThat(manager.getReadyToConnect()).containsOnlyKeys(connection);
        assertThat(manager.getReadyToConnect().get(connection)).isEqualTo(clientID);
        assertThat(manager.getInGame()).isEmpty();

    }

    @Test
    void playerReadyMessagesGetAssignedProperly() {
        manager.messageReceived(
                connection,
                "{\"messageType\":\"PLAYER_READY\",\"startGame\":\"false\",\"role\":\"PLAYER\"}");

        verify(manager).playerReady(
                eq(connection),
                any(PlayerReadyMessage.class));
    }


    @Test
    void characterSelectionMessageGetsAssignedProperly() {
        manager.messageReceived(
                connection,
                "{\"messageType\":\"CHARACTER_SELECTION\",\"characters\":" +
                        "[true, true, false, true, false, false, true, true, false, false, false, true]}");

        verify(manager).charactersSelected(
                eq(connection),
                any(CharacterSelectionMessage.class));
    }

    @Test
    void requestMessagesGetRelayedProperly() {
        manager.messageReceived(
                connection,
                "{\"messageType\":\"REQUESTS\",\"messages\":[{\"requestType\":\"EndRoundRequest\"}]}");

        verify(manager).relayRequestMessage(
                eq(connection),
                any(RequestMessage.class));
    } */
}