package com.lions.dev.service;

import com.lions.dev.security.Permission;
import com.lions.dev.security.Role;
import com.lions.dev.security.RolePermissionConfig;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.security.TestSecurity;
import jakarta.inject.Inject;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.util.Set;
import java.util.UUID;

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

/**
 * Tests unitaires pour le SecurityService.
 * Utilise @TestSecurity pour simuler différents contextes de sécurité.
 * 
 * @since 2.0 - Tests production-ready
 */
@QuarkusTest
class SecurityServiceTest {

    @Inject
    SecurityService securityService;

    @Inject
    RolePermissionConfig rolePermissionConfig;

    // =========================================================================
    // Tests des permissions par rôle
    // =========================================================================

    @Test
    @DisplayName("Role USER devrait avoir les permissions de base")
    void testUserRoleHasBasicPermissions() {
        Set<Permission> userPermissions = rolePermissionConfig.getPermissions(Role.USER);
        
        // Vérifier les permissions de profil
        assertTrue(userPermissions.contains(Permission.PROFILE_READ), "USER devrait pouvoir lire son profil");
        assertTrue(userPermissions.contains(Permission.PROFILE_UPDATE), "USER devrait pouvoir modifier son profil");
        
        // Vérifier les permissions de lecture
        assertTrue(userPermissions.contains(Permission.EVENTS_READ), "USER devrait pouvoir lire les événements");
        assertTrue(userPermissions.contains(Permission.ESTABLISHMENTS_READ), "USER devrait pouvoir lire les établissements");
        
        // Vérifier les permissions de participation
        assertTrue(userPermissions.contains(Permission.EVENTS_PARTICIPATE), "USER devrait pouvoir participer aux événements");
        assertTrue(userPermissions.contains(Permission.RESERVATIONS_CREATE), "USER devrait pouvoir créer des réservations");
        
        // Vérifier l'absence de permissions admin
        assertFalse(userPermissions.contains(Permission.SUPER_ADMIN_ACCESS), "USER ne devrait pas avoir accès super admin");
        assertFalse(userPermissions.contains(Permission.USERS_DELETE_ANY), "USER ne devrait pas pouvoir supprimer d'autres utilisateurs");
    }

    @Test
    @DisplayName("Role ESTABLISHMENT_OWNER devrait avoir les permissions d'établissement")
    void testOwnerRoleHasEstablishmentPermissions() {
        Set<Permission> ownerPermissions = rolePermissionConfig.getPermissions(Role.ESTABLISHMENT_OWNER);
        
        // Permissions de gestion d'établissement
        assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_CREATE), "ESTABLISHMENT_OWNER devrait pouvoir créer un établissement");
        assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_UPDATE_OWN), "ESTABLISHMENT_OWNER devrait pouvoir modifier son établissement");
        assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_DELETE_OWN), "ESTABLISHMENT_OWNER devrait pouvoir supprimer son établissement");
        assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_MANAGE_STAFF), "ESTABLISHMENT_OWNER devrait pouvoir gérer le personnel");
        assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_VIEW_ANALYTICS), "ESTABLISHMENT_OWNER devrait voir les analytics");
        
        // Permissions de promotions
        assertTrue(ownerPermissions.contains(Permission.PROMOTIONS_CREATE), "ESTABLISHMENT_OWNER devrait pouvoir créer des promotions");
        assertTrue(ownerPermissions.contains(Permission.PROMOTIONS_UPDATE_OWN), "ESTABLISHMENT_OWNER devrait pouvoir modifier ses promotions");
        assertTrue(ownerPermissions.contains(Permission.PROMOTIONS_DELETE_OWN), "ESTABLISHMENT_OWNER devrait pouvoir supprimer ses promotions");
    }

    @Test
    @DisplayName("Role SUPER_ADMIN devrait avoir toutes les permissions")
    void testSuperAdminHasAllPermissions() {
        Set<Permission> superAdminPermissions = rolePermissionConfig.getPermissions(Role.SUPER_ADMIN);
        
        // SUPER_ADMIN devrait avoir accès à tout
        assertTrue(superAdminPermissions.contains(Permission.SUPER_ADMIN_ACCESS), "SUPER_ADMIN devrait avoir accès super admin");
        assertTrue(superAdminPermissions.contains(Permission.USERS_DELETE_ANY), "SUPER_ADMIN devrait pouvoir supprimer tout utilisateur");
        assertTrue(superAdminPermissions.contains(Permission.EVENTS_DELETE_ANY), "SUPER_ADMIN devrait pouvoir supprimer tout événement");
        assertTrue(superAdminPermissions.contains(Permission.ESTABLISHMENTS_DELETE_ANY), "SUPER_ADMIN devrait pouvoir supprimer tout établissement");
        assertTrue(superAdminPermissions.contains(Permission.ADMIN_SETTINGS), "SUPER_ADMIN devrait pouvoir modifier les paramètres système");
    }

    @Test
    @DisplayName("Role MODERATOR devrait avoir les permissions de modération")
    void testModeratorRoleHasModerationPermissions() {
        Set<Permission> modPermissions = rolePermissionConfig.getPermissions(Role.MODERATOR);
        
        assertTrue(modPermissions.contains(Permission.MODERATION_VIEW_REPORTS), "MODERATOR devrait voir les signalements");
        assertTrue(modPermissions.contains(Permission.MODERATION_HANDLE_REPORTS), "MODERATOR devrait traiter les signalements");
        assertTrue(modPermissions.contains(Permission.MODERATION_HIDE_CONTENT), "MODERATOR devrait pouvoir masquer du contenu");
        assertTrue(modPermissions.contains(Permission.POSTS_MODERATE), "MODERATOR devrait pouvoir modérer les posts");
        assertTrue(modPermissions.contains(Permission.REVIEWS_MODERATE), "MODERATOR devrait pouvoir modérer les avis");
    }

    // =========================================================================
    // Tests du contexte de sécurité avec @TestSecurity
    // =========================================================================

    @Test
    @TestSecurity(user = "testuser@test.com", roles = {"USER"})
    @DisplayName("Utilisateur authentifié avec rôle USER")
    void testAuthenticatedUserRole() {
        assertTrue(securityService.hasAnyRole("USER"), "Devrait avoir le rôle USER");
        assertFalse(securityService.hasAnyRole("ADMIN"), "Ne devrait pas avoir le rôle ADMIN");
        assertFalse(securityService.hasAnyRole("SUPER_ADMIN"), "Ne devrait pas avoir le rôle SUPER_ADMIN");
    }

    @Test
    @TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
    @DisplayName("Utilisateur authentifié avec rôle ADMIN")
    void testAuthenticatedAdminRole() {
        assertTrue(securityService.hasAnyRole("ADMIN"), "Devrait avoir le rôle ADMIN");
        assertTrue(securityService.hasAnyRole("USER", "ADMIN"), "Devrait avoir USER ou ADMIN");
    }

    @Test
    @TestSecurity(user = "superadmin@test.com", roles = {"SUPER_ADMIN"})
    @DisplayName("Utilisateur authentifié avec rôle SUPER_ADMIN")
    void testAuthenticatedSuperAdminRole() {
        assertTrue(securityService.hasAnyRole("SUPER_ADMIN"), "Devrait avoir le rôle SUPER_ADMIN");
    }

    // =========================================================================
    // Tests des utilitaires de rôle
    // =========================================================================

    @Test
    @DisplayName("Test conversion String vers Role avec fromString")
    void testRoleFromString() {
        // Nouveaux noms de rôles
        assertEquals(Role.USER, Role.fromString("USER"));
        assertEquals(Role.ESTABLISHMENT_OWNER, Role.fromString("ESTABLISHMENT_OWNER"));
        assertEquals(Role.ESTABLISHMENT_MANAGER, Role.fromString("ESTABLISHMENT_MANAGER"));
        assertEquals(Role.ADMIN, Role.fromString("ADMIN"));
        assertEquals(Role.SUPER_ADMIN, Role.fromString("SUPER_ADMIN"));
        assertEquals(Role.MODERATOR, Role.fromString("MODERATOR"));
        assertEquals(Role.SUPPORT, Role.fromString("SUPPORT"));
        assertEquals(Role.FINANCE_MANAGER, Role.fromString("FINANCE_MANAGER"));
        
        // Rétrocompatibilité avec anciens noms
        assertEquals(Role.ESTABLISHMENT_OWNER, Role.fromString("OWNER"));
        assertEquals(Role.ESTABLISHMENT_MANAGER, Role.fromString("MANAGER"));
    }

    @Test
    @DisplayName("Test que chaque rôle a au moins une permission")
    void testAllRolesHavePermissions() {
        for (Role role : Role.values()) {
            Set<Permission> permissions = rolePermissionConfig.getPermissions(role);
            assertFalse(permissions.isEmpty(), "Le rôle " + role + " devrait avoir au moins une permission");
        }
    }

    // =========================================================================
    // Tests des permissions
    // =========================================================================

    @Test
    @DisplayName("Test que toutes les permissions ont une description")
    void testAllPermissionsHaveDescription() {
        for (Permission permission : Permission.values()) {
            assertNotNull(permission.getDescription(), "La permission " + permission + " devrait avoir une description");
            assertFalse(permission.getDescription().isBlank(), "La description de " + permission + " ne devrait pas être vide");
        }
    }

    @Test
    @DisplayName("Role ESTABLISHMENT_MANAGER devrait pouvoir créer des établissements")
    void testManagerCanCreateEstablishments() {
        Set<Permission> managerPermissions = rolePermissionConfig.getPermissions(Role.ESTABLISHMENT_MANAGER);
        assertTrue(managerPermissions.contains(Permission.ESTABLISHMENTS_CREATE), 
            "ESTABLISHMENT_MANAGER devrait pouvoir créer un établissement");
    }
}