Resolved error for goup page

lib/repositories/group_repository.dart

@@ -11,21 +11,17 @@ class GroupRepository {
     return _groupsCollection.doc(groupId).collection('members');
   }
 
-  // Créer un groupe avec ses membres (avec ID du trip)
   Future<String> createGroupWithMembers({
     required Group group,
     required List<GroupMember> members,
   }) async {
     try {
       return await _firestore.runTransaction<String>((transaction) async {
-        // Créer le document avec un ID généré
         final groupRef = _groupsCollection.doc();
         
-        // Ajouter l'ID dans les données
         final groupData = group.toMap();
         transaction.set(groupRef, groupData);
 
-        // Ajouter tous les membres
         for (var member in members) {
           final memberRef = groupRef.collection('members').doc(member.userId);
           transaction.set(memberRef, member.toMap());
@@ -38,38 +34,82 @@ class GroupRepository {
     }
   }
 
-  // NOUVEAU : Récupérer les groupes où l'utilisateur est membre
   Stream<List<Group>> getGroupsByUserId(String userId) {
-    return _groupsCollection.snapshots().asyncMap((snapshot) async {
-      List<Group> userGroups = [];
+    print('===== GroupRepository: getGroupsByUserId START =====');
+    print('UserId recherché: $userId');
+    
+    return _groupsCollection
+        .snapshots()
+        .asyncMap((snapshot) async {
+          print('===== GroupRepository: Nouveau snapshot (${DateTime.now()}) =====');
+          print('Nombre de documents: ${snapshot.docs.length}');
+          
+          List<Group> userGroups = [];
 
-      for (var groupDoc in snapshot.docs) {
-        try {
-          // Vérifier si l'utilisateur est dans la sous-collection members
-          final memberDoc = await groupDoc.reference
-              .collection('members')
-              .doc(userId)
-              .get();
+          for (var groupDoc in snapshot.docs) {
+            try {
+              final groupId = groupDoc.id;
+              print('--- Vérification groupe: $groupId ---');
+              
+              // Vérifier si l'utilisateur est membre
+              final memberDoc = await groupDoc.reference
+                  .collection('members')
+                  .doc(userId)
+                  .get();
 
-          if (memberDoc.exists) {
-            // Charger le groupe avec tous ses membres
-            final group = Group.fromMap(
-              groupDoc.data() as Map<String, dynamic>,
-              groupDoc.id,
-            );
-            final members = await getGroupMembers(groupDoc.id);
-            userGroups.add(group.copyWith(members: members));
+              print('Membre existe dans $groupId: ${memberDoc.exists}');
+
+              if (memberDoc.exists) {
+                print('✓ Utilisateur trouvé dans $groupId');
+                
+                final groupData = groupDoc.data() as Map<String, dynamic>;
+                final group = Group.fromMap(groupData, groupId);
+                
+                final members = await getGroupMembers(groupId);
+                print('${members.length} membres chargés pour $groupId');
+                
+                userGroups.add(group.copyWith(members: members));
+              } else {
+                print('✗ Utilisateur NON membre de $groupId');
+              }
+            } catch (e, stackTrace) {
+              print('ERREUR groupe ${groupDoc.id}: $e');
+              print('StackTrace: $stackTrace');
+            }
           }
-        } catch (e) {
-          print('Erreur lors du traitement du groupe ${groupDoc.id}: $e');
-        }
-      }
 
-      return userGroups;
-    });
+          print('===== Retour: ${userGroups.length} groupes =====');
+          return userGroups;
+        })
+        .distinct((prev, next) {
+          // Comparer les listes pour éviter les doublons
+          if (prev.length != next.length) {
+            print('>>> Changement détecté: ${prev.length} -> ${next.length} groupes');
+            return false;
+          }
+          
+          // Vérifier si les IDs sont identiques
+          final prevIds = prev.map((g) => g.id).toSet();
+          final nextIds = next.map((g) => g.id).toSet();
+          
+          final identical = prevIds.difference(nextIds).isEmpty && 
+                           nextIds.difference(prevIds).isEmpty;
+          
+          if (!identical) {
+            print('>>> Changement détecté: IDs différents');
+          } else {
+            print('>>> Données identiques, émission ignorée');
+          }
+          
+          return identical;
+        })
+        .handleError((error, stackTrace) {
+          print('ERREUR stream: $error');
+          print('StackTrace: $stackTrace');
+          return <Group>[];
+        });
   }
 
-  // Récupérer un groupe par son ID avec ses membres
   Future<Group?> getGroupById(String groupId) async {
     try {
       final doc = await _groupsCollection.doc(groupId).get();
@@ -85,7 +125,6 @@ class GroupRepository {
     }
   }
 
-  // Récupérer un groupe par tripId
   Future<Group?> getGroupByTripId(String tripId) async {
     try {
       final querySnapshot = await _groupsCollection
@@ -105,23 +144,26 @@ class GroupRepository {
     }
   }
 
-  // Récupérer les membres d'un groupe
   Future<List<GroupMember>> getGroupMembers(String groupId) async {
     try {
+      print('Chargement membres pour: $groupId');
       final snapshot = await _membersCollection(groupId).get();
+      print('${snapshot.docs.length} membres trouvés');
       
       return snapshot.docs
-          .map((doc) => GroupMember.fromMap(
-                doc.data() as Map<String, dynamic>,
-                doc.id,
-              ))
+          .map((doc) {
+            return GroupMember.fromMap(
+              doc.data() as Map<String, dynamic>,
+              doc.id,
+            );
+          })
           .toList();
     } catch (e) {
+      print('ERREUR getGroupMembers: $e');
       throw Exception('Erreur lors de la récupération des membres: $e');
     }
   }
 
-  // Ajouter un membre
   Future<void> addMember(String groupId, GroupMember member) async {
     try {
       await _membersCollection(groupId).doc(member.userId).set(member.toMap());
@@ -134,7 +176,6 @@ class GroupRepository {
     }
   }
 
-  // Supprimer un membre
   Future<void> removeMember(String groupId, String userId) async {
     try {
       await _membersCollection(groupId).doc(userId).delete();
@@ -147,7 +188,6 @@ class GroupRepository {
     }
   }
 
-  // Mettre à jour un groupe
   Future<void> updateGroup(String groupId, Group group) async {
     try {
       await _groupsCollection.doc(groupId).update(
@@ -158,7 +198,6 @@ class GroupRepository {
     }
   }
 
-  // Supprimer un groupe
   Future<void> deleteGroup(String groupId) async {
     try {
       final membersSnapshot = await _membersCollection(groupId).get();
@@ -172,7 +211,6 @@ class GroupRepository {
     }
   }
 
-  // Stream des membres en temps réel
   Stream<List<GroupMember>> watchGroupMembers(String groupId) {
     return _membersCollection(groupId).snapshots().map(
           (snapshot) => snapshot.docs