package dev.lions.unionflow.server.api.enums.notification;

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

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.EnumSource;

@DisplayName("Tests pour TypeNotification")
class TypeNotificationTest {

  @Nested
  @DisplayName("Tests des valeurs enum")
  class TestsValeursEnum {

    @Test
    @DisplayName("Test toutes les valeurs enum")
    void testToutesValeurs() {
      TypeNotification[] values = TypeNotification.values();
      assertThat(values).hasSize(37);
    }

    @ParameterizedTest
    @EnumSource(TypeNotification.class)
    @DisplayName("Test getters de base pour toutes les valeurs")
    void testGettersBase(TypeNotification type) {
      assertThat(type.getLibelle()).isNotNull().isNotEmpty();
      assertThat(type.getCategorie()).isNotNull().isNotEmpty();
      assertThat(type.getPriorite()).isNotNull().isNotEmpty();
      assertThat(type.getIcone()).isNotNull().isNotEmpty();
      assertThat(type.getCouleur()).isNotNull().matches("#[0-9A-Fa-f]{6}");
    }

    @ParameterizedTest
    @CsvSource({
        "NOUVEL_EVENEMENT, true",
        "RAPPEL_EVENEMENT, true",
        "EVENEMENT_ANNULE, true",
        "INSCRIPTION_CONFIRMEE, true",
        "COTISATION_DUE, true",
        "NOUVELLE_DEMANDE_AIDE, false",
        "NOUVEAU_MEMBRE, false",
        "SAUVEGARDE_REUSSIE, false"
    })
    @DisplayName("isVisibleUtilisateur - types visibles")
    void testIsVisibleUtilisateur(TypeNotification type, Boolean expected) {
      assertThat(type.isVisibleUtilisateur()).isEqualTo(expected);
    }

    @ParameterizedTest
    @CsvSource({
        "NOUVEL_EVENEMENT, true",
        "RAPPEL_EVENEMENT, true",
        "EVENEMENT_ANNULE, true",
        "COTISATION_DUE, true",
        "COTISATION_RETARD, true",
        "RAPPEL_COTISATION, true",
        "APPEL_SOLIDARITE, true",
        "INSCRIPTION_CONFIRMEE, false",
        "COTISATION_PAYEE, false",
        "NOUVEAU_MEMBRE, false"
    })
    @DisplayName("isActiveeParDefaut - types activés par défaut")
    void testIsActiveeParDefaut(TypeNotification type, Boolean expected) {
      assertThat(type.isActiveeParDefaut()).isEqualTo(expected);
    }
  }

  @Nested
  @DisplayName("Tests isCritique")
  class IsCritiqueTests {

    @ParameterizedTest
    @CsvSource({
        "INSCRIPTION_REFUSEE, true",
        "PAIEMENT_ECHOUE, true",
        "APPEL_SOLIDARITE, true",
        "URGENCE_LOCALE, true",
        "EVENEMENT_ANNULE, false",
        "COTISATION_RETARD, false",
        "NOUVEL_EVENEMENT, false",
        "COTISATION_PAYEE, false"
    })
    @DisplayName("isCritique - types critiques")
    void testIsCritique(TypeNotification type, Boolean expected) {
      assertThat(type.isCritique()).isEqualTo(expected);
    }
  }

  @Nested
  @DisplayName("Tests isRappel")
  class IsRappelTests {

    @ParameterizedTest
    @CsvSource({
        "RAPPEL_EVENEMENT, true",
        "COTISATION_DUE, true",
        "RAPPEL_COTISATION, true",
        "NOUVEL_EVENEMENT, false"
    })
    @DisplayName("isRappel - types de rappel")
    void testIsRappel(TypeNotification type, Boolean expected) {
      assertThat(type.isRappel()).isEqualTo(expected);
    }
  }

  @Nested
  @DisplayName("Tests isPositive")
  class IsPositiveTests {

    @ParameterizedTest
    @CsvSource({
        "INSCRIPTION_CONFIRMEE, true",
        "COTISATION_PAYEE, true",
        "PAIEMENT_CONFIRME, true",
        "ANNIVERSAIRE_MEMBRE, true",
        "NOUVEL_EVENEMENT, false"
    })
    @DisplayName("isPositive - types positifs")
    void testIsPositive(TypeNotification type, Boolean expected) {
      assertThat(type.isPositive()).isEqualTo(expected);
    }
  }

  @Nested
  @DisplayName("Tests getNiveauPriorite")
  class GetNiveauPrioriteTests {

    @ParameterizedTest
    @CsvSource({
        "URGENCE_LOCALE, 1",
        "INSCRIPTION_REFUSEE, 2",
        "PAIEMENT_ECHOUE, 2",
        "EVENEMENT_ANNULE, 3",
        "COTISATION_RETARD, 3",
        "CHANGEMENT_REGLEMENT, 4",
        "RAPPEL_EVENEMENT, 5",
        "NOUVEL_EVENEMENT, 6",
        "COTISATION_PAYEE, 7",
        "ANNIVERSAIRE_MEMBRE, 8"
    })
    @DisplayName("getNiveauPriorite - tous les niveaux")
    void testGetNiveauPriorite(TypeNotification type, int expected) {
      assertThat(type.getNiveauPriorite()).isEqualTo(expected);
    }

    @Test
    @DisplayName("getNiveauPriorite - priorité inconnue (default)")
    void testGetNiveauPrioriteDefault() {
      // Tester avec la réflexion pour créer un type avec priorité inconnue
      try {
        java.lang.reflect.Field prioriteField = TypeNotification.class.getDeclaredField("priorite");
        prioriteField.setAccessible(true);
        String prioriteOriginale = (String) prioriteField.get(TypeNotification.NOUVEL_EVENEMENT);
        
        // Modifier temporairement la priorité à "inconnue"
        prioriteField.set(TypeNotification.NOUVEL_EVENEMENT, "inconnue");
        
        // Maintenant priorité = "inconnue" devrait retourner 6 (default)
        assertThat(TypeNotification.NOUVEL_EVENEMENT.getNiveauPriorite()).isEqualTo(6);
        
        // Restaurer la priorité originale
        prioriteField.set(TypeNotification.NOUVEL_EVENEMENT, prioriteOriginale);
      } catch (Exception e) {
        org.junit.jupiter.api.Assumptions.assumeTrue(false, "Réflexion non disponible");
      }
    }
  }

  @Nested
  @DisplayName("Tests getDelaiExpirationHeures")
  class GetDelaiExpirationHeuresTests {

    @ParameterizedTest
    @CsvSource({
        "URGENCE_LOCALE, 1",
        "INSCRIPTION_REFUSEE, 24",
        "PAIEMENT_ECHOUE, 24",
        "DEMANDE_AIDE_REFUSEE, 24",
        "PROBLEME_TECHNIQUE, 24",
        "EVENEMENT_ANNULE, 48",
        "COTISATION_RETARD, 48",
        "CHANGEMENT_REGLEMENT, 72",
        "RAPPEL_EVENEMENT, 24",
        "NOUVEL_EVENEMENT, 168",
        "COTISATION_PAYEE, 48",
        "ANNIVERSAIRE_MEMBRE, 72"
    })
    @DisplayName("getDelaiExpirationHeures - tous les délais")
    void testGetDelaiExpirationHeures(TypeNotification type, int expected) {
      assertThat(type.getDelaiExpirationHeures()).isEqualTo(expected);
    }

    @Test
    @DisplayName("getDelaiExpirationHeures - tous les cas du switch")
    void testGetDelaiExpirationHeuresTousCas() {
      // Tester tous les cas du switch pour s'assurer que toutes les branches sont couvertes
      // urgent -> 1
      assertThat(TypeNotification.URGENCE_LOCALE.getDelaiExpirationHeures()).isEqualTo(1);
      assertThat(TypeNotification.APPEL_SOLIDARITE.getDelaiExpirationHeures()).isEqualTo(1);
      
      // error -> 24
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.getDelaiExpirationHeures()).isEqualTo(24);
      assertThat(TypeNotification.PAIEMENT_ECHOUE.getDelaiExpirationHeures()).isEqualTo(24);
      assertThat(TypeNotification.DEMANDE_AIDE_REFUSEE.getDelaiExpirationHeures()).isEqualTo(24);
      assertThat(TypeNotification.PROBLEME_TECHNIQUE.getDelaiExpirationHeures()).isEqualTo(24);
      
      // warning -> 48
      assertThat(TypeNotification.EVENEMENT_ANNULE.getDelaiExpirationHeures()).isEqualTo(48);
      assertThat(TypeNotification.COTISATION_RETARD.getDelaiExpirationHeures()).isEqualTo(48);
      assertThat(TypeNotification.MEMBRE_INACTIF.getDelaiExpirationHeures()).isEqualTo(48);
      assertThat(TypeNotification.MAINTENANCE_PROGRAMMEE.getDelaiExpirationHeures()).isEqualTo(48);
      
      // important -> 72
      assertThat(TypeNotification.CHANGEMENT_REGLEMENT.getDelaiExpirationHeures()).isEqualTo(72);
      
      // reminder -> 24
      assertThat(TypeNotification.RAPPEL_EVENEMENT.getDelaiExpirationHeures()).isEqualTo(24);
      assertThat(TypeNotification.COTISATION_DUE.getDelaiExpirationHeures()).isEqualTo(24);
      assertThat(TypeNotification.RAPPEL_COTISATION.getDelaiExpirationHeures()).isEqualTo(24);
      
      // info -> 168
      assertThat(TypeNotification.NOUVEL_EVENEMENT.getDelaiExpirationHeures()).isEqualTo(168);
      assertThat(TypeNotification.EVENEMENT_MODIFIE.getDelaiExpirationHeures()).isEqualTo(168);
      assertThat(TypeNotification.LISTE_ATTENTE.getDelaiExpirationHeures()).isEqualTo(168);
      
      // success -> 48
      assertThat(TypeNotification.COTISATION_PAYEE.getDelaiExpirationHeures()).isEqualTo(48);
      assertThat(TypeNotification.PAIEMENT_CONFIRME.getDelaiExpirationHeures()).isEqualTo(48);
      assertThat(TypeNotification.DEMANDE_AIDE_APPROUVEE.getDelaiExpirationHeures()).isEqualTo(48);
      
      // celebration -> 72
      assertThat(TypeNotification.ANNIVERSAIRE_MEMBRE.getDelaiExpirationHeures()).isEqualTo(72);
    }

    @Test
    @DisplayName("getDelaiExpirationHeures - priorité inconnue (default = 168)")
    void testGetDelaiExpirationHeuresDefault() {
      // Tester avec la réflexion pour créer un type avec priorité inconnue
      try {
        java.lang.reflect.Field prioriteField = TypeNotification.class.getDeclaredField("priorite");
        prioriteField.setAccessible(true);
        String prioriteOriginale = (String) prioriteField.get(TypeNotification.NOUVEL_EVENEMENT);
        
        // Modifier temporairement la priorité à "inconnue"
        prioriteField.set(TypeNotification.NOUVEL_EVENEMENT, "inconnue");
        
        // Maintenant priorité = "inconnue" devrait retourner 168 (default)
        assertThat(TypeNotification.NOUVEL_EVENEMENT.getDelaiExpirationHeures()).isEqualTo(168);
        
        // Restaurer la priorité originale
        prioriteField.set(TypeNotification.NOUVEL_EVENEMENT, prioriteOriginale);
      } catch (Exception e) {
        org.junit.jupiter.api.Assumptions.assumeTrue(false, "Réflexion non disponible");
      }
    }
  }

  @Nested
  @DisplayName("Tests doitVibrer")
  class DoitVibrerTests {

    @ParameterizedTest
    @CsvSource({
        "URGENCE_LOCALE, true",
        "INSCRIPTION_REFUSEE, true",
        "PAIEMENT_ECHOUE, true",
        "RAPPEL_EVENEMENT, true",
        "EVENEMENT_ANNULE, false",
        "NOUVEL_EVENEMENT, false",
        "COTISATION_PAYEE, false"
    })
    @DisplayName("doitVibrer - types qui doivent vibrer")
    void testDoitVibrer(TypeNotification type, Boolean expected) {
      assertThat(type.doitVibrer()).isEqualTo(expected);
    }

    @Test
    @DisplayName("doitVibrer - branche isCritique() == true (court-circuit)")
    void testDoitVibrerCritique() {
      // Types critiques (urgent ou error) doivent vibrer
      // isCritique() retourne true, donc court-circuit et retourne true
      assertThat(TypeNotification.URGENCE_LOCALE.doitVibrer()).isTrue();
      assertThat(TypeNotification.URGENCE_LOCALE.isCritique()).isTrue();
      assertThat(TypeNotification.URGENCE_LOCALE.isRappel()).isFalse();
      
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.doitVibrer()).isTrue();
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.isCritique()).isTrue();
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.isRappel()).isFalse();
    }

    @Test
    @DisplayName("doitVibrer - branche isCritique() == false && isRappel() == true")
    void testDoitVibrerRappel() {
      // Types rappel (mais pas critiques) doivent vibrer
      // isCritique() retourne false, mais isRappel() retourne true
      assertThat(TypeNotification.RAPPEL_EVENEMENT.doitVibrer()).isTrue();
      assertThat(TypeNotification.RAPPEL_EVENEMENT.isCritique()).isFalse();
      assertThat(TypeNotification.RAPPEL_EVENEMENT.isRappel()).isTrue();
      
      assertThat(TypeNotification.COTISATION_DUE.doitVibrer()).isTrue();
      assertThat(TypeNotification.COTISATION_DUE.isCritique()).isFalse();
      assertThat(TypeNotification.COTISATION_DUE.isRappel()).isTrue();
    }

    @Test
    @DisplayName("doitVibrer - branche isCritique() == false && isRappel() == false")
    void testDoitVibrerNiCritiqueNiRappel() {
      // Types ni critiques ni rappels ne doivent pas vibrer
      assertThat(TypeNotification.NOUVEL_EVENEMENT.doitVibrer()).isFalse();
      assertThat(TypeNotification.NOUVEL_EVENEMENT.isCritique()).isFalse();
      assertThat(TypeNotification.NOUVEL_EVENEMENT.isRappel()).isFalse();
      
      assertThat(TypeNotification.COTISATION_PAYEE.doitVibrer()).isFalse();
      assertThat(TypeNotification.COTISATION_PAYEE.isCritique()).isFalse();
      assertThat(TypeNotification.COTISATION_PAYEE.isRappel()).isFalse();
    }
  }

  @Nested
  @DisplayName("Tests doitEmettreSon")
  class DoitEmettreSonTests {

    @ParameterizedTest
    @CsvSource({
        "URGENCE_LOCALE, true",
        "INSCRIPTION_REFUSEE, true",
        "PAIEMENT_ECHOUE, true",
        "RAPPEL_EVENEMENT, true",
        "CHANGEMENT_REGLEMENT, true",
        "EVENEMENT_ANNULE, false",
        "NOUVEL_EVENEMENT, false",
        "COTISATION_PAYEE, false"
    })
    @DisplayName("doitEmettreSon - types qui doivent émettre un son")
    void testDoitEmettreSon(TypeNotification type, Boolean expected) {
      assertThat(type.doitEmettreSon()).isEqualTo(expected);
    }

    @Test
    @DisplayName("doitEmettreSon - branche isCritique() == true (court-circuit)")
    void testDoitEmettreSonCritique() {
      // Types critiques (urgent ou error) doivent émettre un son
      // isCritique() retourne true, donc court-circuit et retourne true
      assertThat(TypeNotification.URGENCE_LOCALE.doitEmettreSon()).isTrue();
      assertThat(TypeNotification.URGENCE_LOCALE.isCritique()).isTrue();
      assertThat(TypeNotification.URGENCE_LOCALE.isRappel()).isFalse();
      assertThat(TypeNotification.URGENCE_LOCALE.getPriorite()).isNotEqualTo("important");
      
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.doitEmettreSon()).isTrue();
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.isCritique()).isTrue();
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.isRappel()).isFalse();
    }

    @Test
    @DisplayName("doitEmettreSon - branche isCritique() == false && isRappel() == true (court-circuit)")
    void testDoitEmettreSonRappel() {
      // Types rappel (mais pas critiques) doivent émettre un son
      // isCritique() retourne false, mais isRappel() retourne true, donc court-circuit
      assertThat(TypeNotification.RAPPEL_EVENEMENT.doitEmettreSon()).isTrue();
      assertThat(TypeNotification.RAPPEL_EVENEMENT.isCritique()).isFalse();
      assertThat(TypeNotification.RAPPEL_EVENEMENT.isRappel()).isTrue();
      assertThat(TypeNotification.RAPPEL_EVENEMENT.getPriorite()).isNotEqualTo("important");
      
      assertThat(TypeNotification.COTISATION_DUE.doitEmettreSon()).isTrue();
      assertThat(TypeNotification.COTISATION_DUE.isCritique()).isFalse();
      assertThat(TypeNotification.COTISATION_DUE.isRappel()).isTrue();
    }

    @Test
    @DisplayName("doitEmettreSon - branche isCritique() == false && isRappel() == false && priorite == important")
    void testDoitEmettreSonImportant() {
      // Types avec priorité "important" (mais ni critiques ni rappels) doivent émettre un son
      assertThat(TypeNotification.CHANGEMENT_REGLEMENT.doitEmettreSon()).isTrue();
      assertThat(TypeNotification.CHANGEMENT_REGLEMENT.isCritique()).isFalse();
      assertThat(TypeNotification.CHANGEMENT_REGLEMENT.isRappel()).isFalse();
      assertThat(TypeNotification.CHANGEMENT_REGLEMENT.getPriorite()).isEqualTo("important");
    }

    @Test
    @DisplayName("doitEmettreSon - branche isCritique() == false && isRappel() == false && priorite != important")
    void testDoitEmettreSonNiCritiqueNiRappelNiImportant() {
      // Types ni critiques, ni rappels, ni important ne doivent pas émettre de son
      assertThat(TypeNotification.NOUVEL_EVENEMENT.doitEmettreSon()).isFalse();
      assertThat(TypeNotification.NOUVEL_EVENEMENT.isCritique()).isFalse();
      assertThat(TypeNotification.NOUVEL_EVENEMENT.isRappel()).isFalse();
      assertThat(TypeNotification.NOUVEL_EVENEMENT.getPriorite()).isNotEqualTo("important");
      
      assertThat(TypeNotification.COTISATION_PAYEE.doitEmettreSon()).isFalse();
      assertThat(TypeNotification.COTISATION_PAYEE.isCritique()).isFalse();
      assertThat(TypeNotification.COTISATION_PAYEE.isRappel()).isFalse();
      assertThat(TypeNotification.COTISATION_PAYEE.getPriorite()).isNotEqualTo("important");
    }
  }

  @Nested
  @DisplayName("Tests getCanalNotification")
  class GetCanalNotificationTests {

    @ParameterizedTest
    @CsvSource({
        "URGENCE_LOCALE, URGENT_CHANNEL",
        "INSCRIPTION_REFUSEE, ERROR_CHANNEL",
        "PAIEMENT_ECHOUE, ERROR_CHANNEL",
        "DEMANDE_AIDE_REFUSEE, ERROR_CHANNEL",
        "PROBLEME_TECHNIQUE, ERROR_CHANNEL",
        "EVENEMENT_ANNULE, WARNING_CHANNEL",
        "COTISATION_RETARD, WARNING_CHANNEL",
        "CHANGEMENT_REGLEMENT, IMPORTANT_CHANNEL",
        "RAPPEL_EVENEMENT, REMINDER_CHANNEL",
        "COTISATION_PAYEE, SUCCESS_CHANNEL",
        "ANNIVERSAIRE_MEMBRE, CELEBRATION_CHANNEL",
        "NOUVEL_EVENEMENT, DEFAULT_CHANNEL"
    })
    @DisplayName("getCanalNotification - tous les canaux")
    void testGetCanalNotification(TypeNotification type, String expected) {
      assertThat(type.getCanalNotification()).isEqualTo(expected);
    }

    @Test
    @DisplayName("getCanalNotification - tous les cas du switch")
    void testGetCanalNotificationTousCas() {
      // Tester tous les cas du switch pour s'assurer que toutes les branches sont couvertes
      // urgent -> URGENT_CHANNEL
      assertThat(TypeNotification.URGENCE_LOCALE.getCanalNotification()).isEqualTo("URGENT_CHANNEL");
      assertThat(TypeNotification.APPEL_SOLIDARITE.getCanalNotification()).isEqualTo("URGENT_CHANNEL");
      
      // error -> ERROR_CHANNEL
      assertThat(TypeNotification.INSCRIPTION_REFUSEE.getCanalNotification()).isEqualTo("ERROR_CHANNEL");
      assertThat(TypeNotification.PAIEMENT_ECHOUE.getCanalNotification()).isEqualTo("ERROR_CHANNEL");
      assertThat(TypeNotification.DEMANDE_AIDE_REFUSEE.getCanalNotification()).isEqualTo("ERROR_CHANNEL");
      assertThat(TypeNotification.PROBLEME_TECHNIQUE.getCanalNotification()).isEqualTo("ERROR_CHANNEL");
      
      // warning -> WARNING_CHANNEL
      assertThat(TypeNotification.EVENEMENT_ANNULE.getCanalNotification()).isEqualTo("WARNING_CHANNEL");
      assertThat(TypeNotification.COTISATION_RETARD.getCanalNotification()).isEqualTo("WARNING_CHANNEL");
      assertThat(TypeNotification.MEMBRE_INACTIF.getCanalNotification()).isEqualTo("WARNING_CHANNEL");
      assertThat(TypeNotification.MAINTENANCE_PROGRAMMEE.getCanalNotification()).isEqualTo("WARNING_CHANNEL");
      
      // important -> IMPORTANT_CHANNEL
      assertThat(TypeNotification.CHANGEMENT_REGLEMENT.getCanalNotification()).isEqualTo("IMPORTANT_CHANNEL");
      
      // reminder -> REMINDER_CHANNEL
      assertThat(TypeNotification.RAPPEL_EVENEMENT.getCanalNotification()).isEqualTo("REMINDER_CHANNEL");
      assertThat(TypeNotification.COTISATION_DUE.getCanalNotification()).isEqualTo("REMINDER_CHANNEL");
      assertThat(TypeNotification.RAPPEL_COTISATION.getCanalNotification()).isEqualTo("REMINDER_CHANNEL");
      
      // success -> SUCCESS_CHANNEL
      assertThat(TypeNotification.COTISATION_PAYEE.getCanalNotification()).isEqualTo("SUCCESS_CHANNEL");
      assertThat(TypeNotification.PAIEMENT_CONFIRME.getCanalNotification()).isEqualTo("SUCCESS_CHANNEL");
      assertThat(TypeNotification.DEMANDE_AIDE_APPROUVEE.getCanalNotification()).isEqualTo("SUCCESS_CHANNEL");
      
      // celebration -> CELEBRATION_CHANNEL
      assertThat(TypeNotification.ANNIVERSAIRE_MEMBRE.getCanalNotification()).isEqualTo("CELEBRATION_CHANNEL");
      
      // info -> DEFAULT_CHANNEL
      assertThat(TypeNotification.NOUVEL_EVENEMENT.getCanalNotification()).isEqualTo("DEFAULT_CHANNEL");
      assertThat(TypeNotification.EVENEMENT_MODIFIE.getCanalNotification()).isEqualTo("DEFAULT_CHANNEL");
      assertThat(TypeNotification.LISTE_ATTENTE.getCanalNotification()).isEqualTo("DEFAULT_CHANNEL");
    }

    @Test
    @DisplayName("getCanalNotification - priorité inconnue (default = DEFAULT_CHANNEL)")
    void testGetCanalNotificationDefault() {
      // Tester avec la réflexion pour créer un type avec priorité inconnue
      try {
        java.lang.reflect.Field prioriteField = TypeNotification.class.getDeclaredField("priorite");
        prioriteField.setAccessible(true);
        String prioriteOriginale = (String) prioriteField.get(TypeNotification.NOUVEL_EVENEMENT);
        
        // Modifier temporairement la priorité à "inconnue"
        prioriteField.set(TypeNotification.NOUVEL_EVENEMENT, "inconnue");
        
        // Maintenant priorité = "inconnue" devrait retourner DEFAULT_CHANNEL (default)
        assertThat(TypeNotification.NOUVEL_EVENEMENT.getCanalNotification()).isEqualTo("DEFAULT_CHANNEL");
        
        // Restaurer la priorité originale
        prioriteField.set(TypeNotification.NOUVEL_EVENEMENT, prioriteOriginale);
      } catch (Exception e) {
        org.junit.jupiter.api.Assumptions.assumeTrue(false, "Réflexion non disponible");
      }
    }
  }
}

