package ru.soune.nocopy.service;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.context.MessageSource;
import org.springframework.security.crypto.password.PasswordEncoder;
import ru.soune.nocopy.dto.LoginRequest;
import ru.soune.nocopy.entity.AuthToken;
import ru.soune.nocopy.entity.User;
import ru.soune.nocopy.exception.NotValidationPasswordException;
import ru.soune.nocopy.exception.UserNotFoundException;
import ru.soune.nocopy.repository.AuthTokenRepository;
import ru.soune.nocopy.repository.UserRepository;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

public class AuthServiceTest {

    @Mock
    private UserRepository userRepository;

    @Mock
    private AuthTokenRepository authTokenRepository;

    @Mock
    private PasswordEncoder passwordEncoder;

    @Mock
    private MessageSource messageSource;

    @InjectMocks
    private AuthService authService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void login_success() {
        LoginRequest request = new LoginRequest("test@mail.com", "password");

        User user = new User();
        user.setId(1L);
        user.setEmail("test@mail.com");
        user.setPassword("encoded_pass");

        when(userRepository.findByEmail("test@mail.com"))
                .thenReturn(Optional.of(user));
        when(passwordEncoder.matches("password", "encoded_pass"))
                .thenReturn(true);
        when(authTokenRepository.save(any(AuthToken.class)))
                .thenAnswer(invocation -> invocation.getArgument(0));

        AuthToken token = authService.login(request);

        assertNotNull(token);
        assertNotNull(token.getToken());
//        assertEquals(user.getTokens().get(0), token.getUser());

        ArgumentCaptor<AuthToken> captor = ArgumentCaptor.forClass(AuthToken.class);
        verify(authTokenRepository).save(captor.capture());

//        assertEquals(user, captor.getValue().getUser());
        assertNotNull(captor.getValue().getToken());
    }


    @Test
    void login_userNotFound() {
        LoginRequest request = new LoginRequest("missing@mail.com", "pwd");

        when(userRepository.findByEmail("missing@mail.com")).thenReturn(Optional.empty());

        assertThrows(UserNotFoundException.class, () -> authService.login(request));
    }


    @Test
    void login_invalidPassword() {
        LoginRequest request = new LoginRequest("test@mail.com", "wrong");

        User user = new User();
        user.setEmail("test@mail.com");
        user.setPassword("encoded_pass");

        when(userRepository.findByEmail("test@mail.com")).thenReturn(Optional.of(user));
        when(passwordEncoder.matches("wrong", "encoded_pass")).thenReturn(false);

        assertThrows(NotValidationPasswordException.class, () -> authService.login(request));
    }
}