package com.example.familymap;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import org.junit.After;
import org.junit.Before;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import request.EventRequest;
import request.LoginRequest;
import request.PersonRequest;
import request.RegisterRequest;
import result.EventsResult;
import result.LoginResult;
import result.PersonsResult;
import result.RegisterResult;

public class ServerProxyTests
{
    private ServerProxy proxy;

    @BeforeEach
    public void setUp()
    {
        proxy = new ServerProxy("localhost", "8080");
    }

    @AfterEach
    public void tearDown()
    {
        proxy.clear();
    }

    @Test
    public void proxyRegisterPass()
    {
        RegisterRequest request = new RegisterRequest("DaveB", "abc123",
                "email@gmail.com", "Dave", "Barrows", "m");

        RegisterResult result = proxy.register(request);

        assertNotNull(result.getAuthtoken());

        assertEquals(request.getUsername(), result.getUsername());

        assertNotNull(result.getPersonID());

        assertTrue(result.isSuccess());
    }

    @Test
    public void proxyRegisterFail()
    {
        //Checks to make sure we correctly register the first person
        RegisterRequest request = new RegisterRequest("JohnW", "password", "johnw@gmail.com",
                "John", "Williams", "m");

        RegisterResult result = proxy.register(request);

        assertNotNull(result.getAuthtoken());

        assertEquals(request.getUsername(), result.getUsername());

        assertNotNull(result.getPersonID());

        assertTrue(result.isSuccess());

        //Now we attempt to register a duplicate username, which should result in an error
        RegisterRequest duplicateRequest = new RegisterRequest("JohnW", "abc123", "jonathanw@gmail.com",
                "John", "Wesker", "m");

        RegisterResult result2 = proxy.register(duplicateRequest);

        assertTrue(result2.getMessage().contains("Error:"));
        assertFalse(result2.isSuccess());
    }

    @Test
    public void proxyLoginPass()
    {
        //Registering a new user so we can also attempt to log them in
        RegisterRequest registerRequest = new RegisterRequest("AliceA", "password", "aa@gmail.com",
                "Alice", "Adams", "f");

        RegisterResult registerResult = proxy.register(registerRequest);

        assertNotNull(registerResult.getAuthtoken());

        assertEquals(registerRequest.getUsername(), registerResult.getUsername());

        assertNotNull(registerResult.getPersonID());

        assertTrue(registerResult.isSuccess());

        //Attempting to log the user in
        LoginRequest loginRequest = new LoginRequest(registerRequest.getUsername(), registerRequest.getPassword());

        LoginResult loginResult = proxy.login(loginRequest);

        assertNotNull(loginResult.getAuthToken());

        assertEquals(loginRequest.getUsername(), loginResult.getUsername());

        assertNotNull(loginResult.getPersonID());

        assertTrue(loginResult.isSuccess());
    }

    @Test
    public void proxyLoginFail()
    {
        //Attempting to log a user in that does not exist in the database
        LoginRequest request = new LoginRequest("Daniel", "abc123");

        LoginResult result = proxy.login(request);

        assertTrue(result.getMessage().contains("Error:"));
        assertFalse(result.isSuccess());

        proxy.login(request);
    }

    @Test
    public void retrievePersonsPass()
    {
        RegisterRequest registerRequest = new RegisterRequest("DannyF", "password", "dannyf@gmail.com",
                "Danny", "Fenton", "m");

        RegisterResult registerResult = proxy.register(registerRequest);

        PersonRequest request = new PersonRequest(registerResult.getPersonID(), registerResult.getAuthtoken());

        PersonsResult result = proxy.getPersons(request);

        assertNotNull(result.getData());

        //Checks to make sure there are 31 persons in the database (the default amount generated when registering)
        assertEquals(result.getData().size(), 31);

        //Checking to make sure that each person that is returned has a valid personID
        for (int i = 0; i < result.getData().size(); i++)
        {
            assertNotNull(result.getData().get(i).getPersonID());
        }

        assertTrue(result.isSuccess());
    }

    @Test
    public void retrievePersonsFail()
    {
        //Attempting to retrieve persons with an invalid authToken
        RegisterRequest registerRequest = new RegisterRequest("DonL", "password", "donaldl@gmail.com",
                "Don", "Lee", "m");

        RegisterResult registerResult = proxy.register(registerRequest);

        String invalidAuthToken = "invalid";

        PersonRequest request = new PersonRequest(registerResult.getPersonID(), invalidAuthToken);

        PersonsResult result = proxy.getPersons(request);

        assertTrue(result.getMessage().contains("Error:"));
        assertFalse(result.isSuccess());
    }

    @Test
    public void retrieveEventsPass()
    {
        RegisterRequest registerRequest = new RegisterRequest("EmmaJ", "password", "emmaj@gmail.com",
                "Emma", "Jones", "f");

        RegisterResult registerResult = proxy.register(registerRequest);

        EventRequest request = new EventRequest(registerResult.getPersonID(), registerResult.getAuthtoken());

        EventsResult result = proxy.getEvents(request);

        assertNotNull(result.getData());

        //Checks to make sure there are 123 events in the database (the default amount generated when registering)
        assertEquals(result.getData().size(), 123);

        //Checking to make sure that each event that is returned has a valid eventID
        for (int i = 0; i < result.getData().size(); i++)
        {
            assertNotNull(result.getData().get(i).getEventID());
        }

        assertTrue(result.isSuccess());
    }

    @Test
    public void retrieveEventsFail()
    {
        //Attempting to retrieve events with an invalid authToken
        RegisterRequest registerRequest = new RegisterRequest("William", "password", "willy@gmail.com",
                "William", "Duncan", "m");

        RegisterResult registerResult = proxy.register(registerRequest);

        String invalidAuthToken = "invalid";

        PersonRequest request = new PersonRequest(registerResult.getPersonID(), invalidAuthToken);

        PersonsResult result = proxy.getPersons(request);

        assertTrue(result.getMessage().contains("Error:"));
        assertFalse(result.isSuccess());
    }
}