package eu.ztsh.wymiana.service;

import eu.ztsh.wymiana.EntityCreator;
import eu.ztsh.wymiana.RepositoryBasedTest;
import eu.ztsh.wymiana.data.repository.UserRepository;
import eu.ztsh.wymiana.exception.UserAlreadyExistsException;
import eu.ztsh.wymiana.util.UserMapper;
import eu.ztsh.wymiana.validation.Adult;
import eu.ztsh.wymiana.validation.InstanceValidator;
import eu.ztsh.wymiana.validation.ValidationFailedException;
import jakarta.transaction.Transactional;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

class UserServiceTest extends RepositoryBasedTest {

    private final UserService userService;

    @Autowired
    public UserServiceTest(UserRepository userRepository, InstanceValidator instanceValidator) {
        super(userRepository);
        userService = new UserService(userRepository, instanceValidator);
    }

    @Test
    @Transactional
    @DisplayName("Create new user")
    void createNewUserTest() {
        userService.create(EntityCreator.userRequest().build());
        var entity = EntityCreator.userEntity().build();
        expect(entity);
    }

    @Test
    @DisplayName("Try to create user that already exists")
    void createDuplicatedUserTest() {
        var first = EntityCreator.userRequest().build();
        var second = EntityCreator.userRequest().build();
        userService.create(first);
        assertThatThrownBy(() -> userService.create(second))
                .isInstanceOf(UserAlreadyExistsException.class)
                .hasMessage("User with PESEL %s already exists".formatted(EntityCreator.Constants.PESEL));
    }

    @Test
    @DisplayName("Try to create another user with same PESEL")
    void createDuplicatedPeselTest() {
        var first = EntityCreator.userRequest().build();
        var second = EntityCreator.userRequest()
                .name("Jan")
                .surname("Kowalski")
                .pln(30.30)
                .build();
        userService.create(first);
        assertThatThrownBy(() -> userService.create(second))
                .isInstanceOf(UserAlreadyExistsException.class)
                .hasMessage("User with PESEL %s already exists".formatted(EntityCreator.Constants.PESEL));
    }

    @Test
    @DisplayName("Try to create too young user")
    void youngUserTest() {
        var request = EntityCreator.userRequest().pesel("").build();
        assertThatThrownBy(() -> userService.create(request))
                .isInstanceOf(ValidationFailedException.class)
                .hasMessageContaining(Adult.MESSAGE);
    }

    @Test
    @Transactional
    @DisplayName("Get existing user")
    void getExistingUserTest() {
        var entity = EntityCreator.userEntity().build();
        userRepository.save(entity);
        var userOptional = userService.get(EntityCreator.Constants.PESEL);
        var expected = UserMapper.entityToPojo(entity);
        assertThat(userOptional)
                .isNotEmpty()
                .get()
                .usingRecursiveComparison()
                .isEqualTo(expected);
    }

    @Test
    @DisplayName("Try get non-existing user")
    void getNonExistingUserTest() {
        var userOptional = userService.get(EntityCreator.Constants.PESEL);
        assertThat(userOptional).isEmpty();
    }

}