package ru.soune.no_copy.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.no_copy.dto.LoginRequest;
import ru.soune.no_copy.dto.RegisterRequest;
import ru.soune.no_copy.entity.AuthToken;
import ru.soune.no_copy.entity.User;
import ru.soune.no_copy.exception.NotValidationPasswordException;
import ru.soune.no_copy.exception.UserAlreadyExistsException;
import ru.soune.no_copy.exception.UserNotFoundException;
import ru.soune.no_copy.repository.AuthTokenRepository;
import ru.soune.no_copy.repository.UserRepository;

import java.util.Locale;
import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
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 registerSuccess() {
        RegisterRequest request = new RegisterRequest("John","A.","Doe",
                "john@example.com", "password123");

        when(userRepository.existsByEmail(request.email())).thenReturn(false);
        when(passwordEncoder.encode(request.password())).thenReturn("hashed");
        when(userRepository.save(any(User.class))).thenAnswer(invocation -> invocation.getArgument(0));
        when(authTokenRepository.save(any(AuthToken.class))).thenAnswer(invocation -> invocation.getArgument(0));

        AuthToken token = authService.register(request);
        User user = token.getUser();
        String email = user.getEmail();

        assertNotNull(token);
        assertNotNull(token.getToken());
        assertNotNull(token.getUser());
        assertEquals("john@example.com", email);
        assertNotNull(token.getExpiresAt());
    }

    @Test
    void registerExistingEmailThrows() {
        RegisterRequest request = new RegisterRequest("John","A.","Doe",
                "john@example.com", "password123");

        when(userRepository.existsByEmail(request.email()))
                .thenReturn(true);
        when(messageSource.getMessage(anyString(), any(), any(Locale.class)))
                .thenReturn("User exists");

        UserAlreadyExistsException ex = assertThrows(UserAlreadyExistsException.class,
                () -> authService.register(request));

        assertEquals("User exists", ex.getMessage());
    }

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

        User user = new User();
        user.setUserId(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, 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));
    }
}