package service;

import model.Utilisateur;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import jakarta.validation.ConstraintViolation;
import jakarta.validation.ConstraintViolationException;
import repository.UtilisateurRepository;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;


import static org.junit.jupiter.api.Assertions.assertThrows;

class UtilisateurServiceTest {

	@Mock
    private UtilisateurRepository utilisateurRepository;

    @InjectMocks
    private UtilisateurService utilisateurService;
    
    @Spy
    private UtilisateurService utilisateurServiceSpy;

    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    @BeforeEach
    void setUp() {
    	MockitoAnnotations.openMocks(this);
    	passwordEncoder = mock(BCryptPasswordEncoder.class);
        utilisateurService = new UtilisateurService(); // Réinitialisez l'objet utilisateurService avec le passwordEncoder simulé.
        utilisateurService.setUtilisateurRepository(utilisateurRepository);
        utilisateurService.setPasswordEncoder(passwordEncoder);
    }

    @Test
    void testCreerUtilisateur() {
        Utilisateur utilisateur = new Utilisateur();
        utilisateur.setNomUtilisateur("utilisateur1");
        utilisateur.setMotDePasse("motdepasse");
        
        String motDePasseCrypte = passwordEncoder.encode(utilisateur.getMotDePasse());
        when(utilisateurRepository.save(utilisateur)).thenReturn(utilisateur);

        Utilisateur nouveauUtilisateur = utilisateurService.creerUtilisateur(utilisateur);

        assertNotNull(nouveauUtilisateur);
        assertEquals(utilisateur.getNomUtilisateur(), nouveauUtilisateur.getNomUtilisateur());
        assertEquals(motDePasseCrypte, nouveauUtilisateur.getMotDePasse());

        verify(utilisateurRepository, times(1)).save(utilisateur);
    }

    @Test
    void testMettreAJourUtilisateur() {
        Long userId = 1L;
        Utilisateur utilisateur = new Utilisateur();
        utilisateur.setId(userId);
        utilisateur.setNomUtilisateur("utilisateur1");
        utilisateur.setMotDePasse("motdepasse");

        when(utilisateurRepository.existsById(userId)).thenReturn(true);
        when(utilisateurRepository.save(utilisateur)).thenReturn(utilisateur);

        Utilisateur utilisateurMisAJour = utilisateurService.mettreAJourUtilisateur(userId, utilisateur);

        assertNotNull(utilisateurMisAJour);
        assertEquals(utilisateur.getId(), utilisateurMisAJour.getId());
        assertEquals(utilisateur.getNomUtilisateur(), utilisateurMisAJour.getNomUtilisateur());
        assertEquals(utilisateur.getMotDePasse(), utilisateurMisAJour.getMotDePasse());

        verify(utilisateurRepository, times(1)).save(utilisateur);
    }

    @Test
    void testSupprimerUtilisateur() {
        Long userId = 1L;

        doNothing().when(utilisateurRepository).deleteById(userId);

        utilisateurService.supprimerUtilisateur(userId);

        verify(utilisateurRepository, times(1)).deleteById(userId);
    }
    
    @Test
    void testCreerUtilisateurChampManquant() {
        Utilisateur utilisateur = new Utilisateur();

        doThrow(ConstraintViolationException.class)
        .when(utilisateurRepository).save(utilisateur);

        ConstraintViolationException exception = assertThrows(ConstraintViolationException.class, () -> {
	        utilisateurService.creerUtilisateur(utilisateur);
	    });
	    
	    assertEquals("Le nom d'utilisateur doit-être renseigné", exception.getMessage());
    }
    
    @Test
    void testMettreAJourUtilisateurChampManquant() {
    	Utilisateur utilisateur = new Utilisateur();
        // Configurer l'utilisateur avec des champs manquants

    	doThrow(ConstraintViolationException.class)
	        .when(utilisateurServiceSpy)
	        .mettreAJourUtilisateur(anyLong(), any(Utilisateur.class));
        
        ConstraintViolationException exception = assertThrows(ConstraintViolationException.class, () -> {
            utilisateurServiceSpy.mettreAJourUtilisateur(1L, utilisateur);
        });
        
        assertEquals("Le nom d'utilisateur doit-être renseigné", exception.getMessage());
    }
    
    @Test
    void testCreerUtilisateurLimiteTailleNomUtilisateur() {
        Utilisateur utilisateur = new Utilisateur();
        utilisateur.setNomUtilisateur("123456789012345678901234567890123456789012345678901"); // 51 caractères
        utilisateur.setMotDePasse("12345678901234567890");

        // Simuler l'échec de l'enregistrement avec la taille du nom utilisateur trop grande
        doThrow(ConstraintViolationException.class)
                .when(utilisateurRepository).save(utilisateur);

        ConstraintViolationException exception = assertThrows(ConstraintViolationException.class, () -> {
            utilisateurService.creerUtilisateur(utilisateur);
        });
        
        assertEquals("Le nom d'utilisateur doit contenir entre 3 et 50 caractères", exception.getMessage());

        // Vérifier que la méthode save a été appelée
        verify(utilisateurRepository, times(1)).save(utilisateur);
    }

    @Test
    void testCreerUtilisateurLimiteTailleMotDePasse() {
        Utilisateur utilisateur = new Utilisateur();
        utilisateur.setNomUtilisateur("utilisateur1");
        utilisateur.setMotDePasse("123456789012345678901234567890123456789012345678901"); // 51 caractères

        doThrow(ConstraintViolationException.class)
        .when(utilisateurRepository).save(utilisateur);

        ConstraintViolationException exception = assertThrows(ConstraintViolationException.class, () -> {
            utilisateurService.creerUtilisateur(utilisateur);
        });

        assertEquals("Le mot de passe doit contenir entre 10 et 50 caractères", exception.getMessage());
    }

    @Test
    void testMettreAJourUtilisateurLimiteTailleNomUtilisateur() {
        Long userId = 1L;
        Utilisateur utilisateur = new Utilisateur();
        utilisateur.setId(userId);
        utilisateur.setNomUtilisateur("123456789012345678901234567890123456789012345678901"); // 51 caractères
        
        doThrow(ConstraintViolationException.class)
            .when(utilisateurServiceSpy)
            .mettreAJourUtilisateur(userId, utilisateur);

        ConstraintViolationException exception = assertThrows(ConstraintViolationException.class, () -> {
            utilisateurServiceSpy.mettreAJourUtilisateur(userId, utilisateur);
        });
        
        assertEquals("Le nom d'utilisateur doit contenir entre 3 et 50 caractères", exception.getMessage());
    }

    @Test
    void testMettreAJourUtilisateurLimiteTailleMotDePasse() {
        Long userId = 1L;
        Utilisateur utilisateur = new Utilisateur();
        utilisateur.setId(userId);
        utilisateur.setNomUtilisateur("utilisateur1");
        utilisateur.setMotDePasse("123456789012345678901234567890123456789012345678901"); // 51 caractères
        
        doThrow(ConstraintViolationException.class)
        .when(utilisateurServiceSpy)
        .mettreAJourUtilisateur(userId, utilisateur);

        ConstraintViolationException exception = assertThrows(ConstraintViolationException.class, () -> {
            utilisateurServiceSpy.mettreAJourUtilisateur(userId, utilisateur);
        });
        
        assertEquals("Le mot de passe doit contenir entre 10 et 50 caractères", exception.getMessage());
    }
}