package com.capgemini.capcup.services;

import com.capgemini.capcup.common.mappers.UserMapper;
import com.capgemini.capcup.common.to.UserTO;
import com.capgemini.capcup.common.to.android.RegisterRequestTO;
import com.capgemini.capcup.common.types.RoleName;
import com.capgemini.capcup.persistence.model.RegisterConfirmationEntity;
import com.capgemini.capcup.persistence.model.RoleEntity;
import com.capgemini.capcup.persistence.model.UserEntity;
import com.capgemini.capcup.persistence.repositories.RoleRepository;
import com.capgemini.capcup.persistence.repositories.UserRepository;
import com.capgemini.capcup.services.scores.ScoreAllocationService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.*;

import static org.assertj.core.api.Java6Assertions.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@RunWith(SpringRunner.class)
@DirtiesContext
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void shouldUserServiceCreateNewUserTest() throws Exception {
        // given
        final RegisterRequestTO request = registerRequestTO();
        final UserEntity userEntity = userEntity(false);
        final RoleEntity userRole = userRole();
        final RegisterConfirmationEntity confirmation = registerConfirmationEntity(userEntity);

        when(UserServiceTestContextConfiguration.userMapper.map(request, UserEntity.class))
                .thenReturn(userEntity);

        when(UserServiceTestContextConfiguration.roleRepository.findByName(Mockito.eq(RoleName.ROLE_USER)))
                .thenReturn(userRole);

        when(UserServiceTestContextConfiguration.encoder.encode(userEntity.getPassword()))
                .thenReturn(new String());

        userEntity.setConfirmation(confirmation);

        when(UserServiceTestContextConfiguration.userRepository.save(Mockito.any(UserEntity.class)))
                .thenReturn(userEntity);

        // when
        final UserEntity created = userService.createUser(request);

        // then
        assertThat(created).isEqualTo(userEntity);

        verify(UserServiceTestContextConfiguration.userMapper).map(request, UserEntity.class);
        verify(UserServiceTestContextConfiguration.roleRepository).findByName(Mockito.eq(RoleName.ROLE_USER));
        verify(UserServiceTestContextConfiguration.encoder).encode(Mockito.any());
        verify(UserServiceTestContextConfiguration.userRepository).save(Mockito.any(UserEntity.class));
    }

    @Test
    public void shouldReturn2UsersTest() throws Exception {
        // given
        final RoleEntity userRole = userRole();
        final RoleEntity adminRole = adminRole();

        final UserEntity user = userEntity(true);
        user.getRoles().add(userRole);
        userRole.getUsers().add(user);

        final UserEntity admin = userEntity(true);
        admin.getRoles().add(userRole);
        userRole.getUsers().add(admin);
        admin.getRoles().add(adminRole);
        adminRole.getUsers().add(admin);

        final List<UserEntity> users = Arrays.asList(user, admin);

        final UserTO userTO = userTO();
        userTO.getRoles().add("ROLE_USER");

        final UserTO adminTO = userTO();
        adminTO.getRoles().addAll(Arrays.asList("ROLE_USER", "ROLE_ADMIN"));

        final List<UserTO> userTOList = Arrays.asList(userTO, adminTO);

        when(UserServiceTestContextConfiguration.userRepository.findAll())
                .thenReturn(users);

        when(UserServiceTestContextConfiguration.userMapper.map(eq(user), eq(UserTO.class)))
                .thenReturn(userTO);

        when(UserServiceTestContextConfiguration.userMapper.map(eq(admin), eq(UserTO.class)))
                .thenReturn(adminTO);

        // when
        final List<UserTO> result = userService.findAllUsers();

        // then
        assertThat(result).isEqualTo(userTOList);

        verify(UserServiceTestContextConfiguration.userRepository).findAll();
        verify(UserServiceTestContextConfiguration.userMapper).map(eq(user), eq(UserTO.class));
        verify(UserServiceTestContextConfiguration.userMapper).map(eq(admin), eq(UserTO.class));
    }

    @Test
    public void shouldFind2RolesTest() throws Exception {
        // given
        final List<RoleEntity> roles = Arrays.asList(userRole(), adminRole());
        final List<String> rolesTO = Arrays.asList("ROLE_USER", "ROLE_ADMIN");

        when(UserServiceTestContextConfiguration.roleRepository.findAll())
                .thenReturn(roles);

        // when
        final List<String> result = userService.findAllRoles();

        // then
        assertThat(result).isEqualTo(rolesTO);

        verify(UserServiceTestContextConfiguration.roleRepository)
                .findAll();
    }

    @Test
    public void shouldReturnNullCollectionTest() throws Exception {
        // given
        when(UserServiceTestContextConfiguration.roleRepository.findAll())
                .thenReturn(null);

        // when
        final List<String> result = userService.findAllRoles();

        // then
        assertThat(result).isEqualTo(Collections.emptyList());

        verify(UserServiceTestContextConfiguration.roleRepository).findAll();
    }

    private UserEntity userEntity(boolean enable) {
        return new UserEntity(
                1L,
                "userek",
                "userek@email.com",
                "pass",
                new ArrayList<>(),
                new HashSet<>(),
                enable,
                null
        );
    }

    private RegisterConfirmationEntity registerConfirmationEntity(UserEntity userEntity) {
        return new RegisterConfirmationEntity(
                userEntity.getId(),
                userEntity,
                UUID.randomUUID(),
                userEntity.getEnabled()
        );
    }

    private UserTO userTO() {
        return new UserTO(
                "userek",
                "userek@email.com",
                "pass"
        );
    }

    private RegisterRequestTO registerRequestTO() {
        return new RegisterRequestTO(
                "userek",
                "userek@email.com",
                "pass"
        );
    }

    private RoleEntity userRole() {
        return new RoleEntity(
                1L,
                RoleName.ROLE_USER,
                new HashSet<>()
        );
    }

    private RoleEntity adminRole() {
        return new RoleEntity(
                2L,
                RoleName.ROLE_ADMIN,
                new HashSet<>()
        );
    }

    @TestConfiguration
    static class UserServiceTestContextConfiguration {

        @MockBean
        private static UserRepository userRepository;

        @MockBean
        private static RoleRepository roleRepository;

        @MockBean
        private static UserMapper userMapper;

        @MockBean
        private static BCryptPasswordEncoder encoder;

        @MockBean
        private static PasswordRestoreService passwordRestoreService;

        @MockBean
        private static ScoreAllocationService scoreAllocationService;

        @Bean
        UserService userService() {
            return new UserServiceImpl(
                    userRepository,
                    roleRepository,
                    userMapper,
                    encoder,
                    passwordRestoreService,
                    scoreAllocationService
            );
        }
    }
}