TravelMate/lib/repositories/group_repository.dart

import 'package:cloud_firestore/cloud_firestore.dart';
import '../data/models/group.dart';
import '../data/models/group_member.dart';

class GroupRepository {
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;

  CollectionReference get _groupsCollection => _firestore.collection('groups');

  CollectionReference _membersCollection(String groupId) {
    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());
        }

        return groupRef.id;
      });
    } catch (e) {
      throw Exception('Erreur lors de la création du groupe: $e');
    }
  }

  // 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 = [];

      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();

          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));
          }
        } catch (e) {
          print('Erreur lors du traitement du groupe ${groupDoc.id}: $e');
        }
      }

      return userGroups;
    });
  }

  // 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();
      
      if (!doc.exists) return null;
      
      final group = Group.fromMap(doc.data() as Map<String, dynamic>, doc.id);
      final members = await getGroupMembers(groupId);
      
      return group.copyWith(members: members);
    } catch (e) {
      throw Exception('Erreur lors de la récupération du groupe: $e');
    }
  }

  // Récupérer un groupe par tripId
  Future<Group?> getGroupByTripId(String tripId) async {
    try {
      final querySnapshot = await _groupsCollection
          .where('tripId', isEqualTo: tripId)
          .limit(1)
          .get();

      if (querySnapshot.docs.isEmpty) return null;

      final doc = querySnapshot.docs.first;
      final group = Group.fromMap(doc.data() as Map<String, dynamic>, doc.id);
      final members = await getGroupMembers(doc.id);
      
      return group.copyWith(members: members);
    } catch (e) {
      throw Exception('Erreur lors de la récupération du groupe: $e');
    }
  }

  // Récupérer les membres d'un groupe
  Future<List<GroupMember>> getGroupMembers(String groupId) async {
    try {
      final snapshot = await _membersCollection(groupId).get();
      
      return snapshot.docs
          .map((doc) => GroupMember.fromMap(
                doc.data() as Map<String, dynamic>,
                doc.id,
              ))
          .toList();
    } catch (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());
      
      await _groupsCollection.doc(groupId).update({
        'updatedAt': DateTime.now().millisecondsSinceEpoch,
      });
    } catch (e) {
      throw Exception('Erreur lors de l\'ajout du membre: $e');
    }
  }

  // Supprimer un membre
  Future<void> removeMember(String groupId, String userId) async {
    try {
      await _membersCollection(groupId).doc(userId).delete();
      
      await _groupsCollection.doc(groupId).update({
        'updatedAt': DateTime.now().millisecondsSinceEpoch,
      });
    } catch (e) {
      throw Exception('Erreur lors de la suppression du membre: $e');
    }
  }

  // Mettre à jour un groupe
  Future<void> updateGroup(String groupId, Group group) async {
    try {
      await _groupsCollection.doc(groupId).update(
            group.toMap()..['updatedAt'] = DateTime.now().millisecondsSinceEpoch,
          );
    } catch (e) {
      throw Exception('Erreur lors de la mise à jour du groupe: $e');
    }
  }

  // Supprimer un groupe
  Future<void> deleteGroup(String groupId) async {
    try {
      final membersSnapshot = await _membersCollection(groupId).get();
      for (var doc in membersSnapshot.docs) {
        await doc.reference.delete();
      }
      
      await _groupsCollection.doc(groupId).delete();
    } catch (e) {
      throw Exception('Erreur lors de la suppression du groupe: $e');
    }
  }

  // Stream des membres en temps réel
  Stream<List<GroupMember>> watchGroupMembers(String groupId) {
    return _membersCollection(groupId).snapshots().map(
          (snapshot) => snapshot.docs
              .map((doc) => GroupMember.fromMap(
                    doc.data() as Map<String, dynamic>,
                    doc.id,
                  ))
              .toList(),
        );
  }
}