TravelMate/lib/blocs/group/group_bloc.dart

import 'dart:async';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'group_event.dart';
import 'group_state.dart';
import '../../repositories/group_repository.dart';

class GroupBloc extends Bloc<GroupEvent, GroupState> {
  final GroupRepository _repository;
  StreamSubscription? _groupsSubscription;

  GroupBloc(this._repository) : super(GroupInitial()) {
    on<LoadGroupsByUserId>(_onLoadGroupsByUserId);
    on<LoadGroupsByTrip>(_onLoadGroupsByTrip);
    on<CreateGroup>(_onCreateGroup);
    on<CreateGroupWithMembers>(_onCreateGroupWithMembers);
    on<AddMemberToGroup>(_onAddMemberToGroup);
    on<RemoveMemberFromGroup>(_onRemoveMemberFromGroup);
    on<UpdateGroup>(_onUpdateGroup);
    on<DeleteGroup>(_onDeleteGroup);
  }

  // NOUVEAU : Charger les groupes par userId
  Future<void> _onLoadGroupsByUserId(
    LoadGroupsByUserId event,
    Emitter<GroupState> emit,
  ) async {
    emit(GroupLoading());

    await _groupsSubscription?.cancel();
    
    _groupsSubscription = _repository.getGroupsByUserId(event.userId).listen(
      (groups) => emit(GroupsLoaded(groups)),
      onError: (error) => emit(GroupError(error.toString())),
    );
  }

  // Charger les groupes d'un voyage (conservé)
  Future<void> _onLoadGroupsByTrip(
    LoadGroupsByTrip event,
    Emitter<GroupState> emit,
  ) async {
    try {
      emit(GroupLoading());
      final group = await _repository.getGroupByTripId(event.tripId);
      if (group != null) {
        emit(GroupsLoaded([group]));
      } else {
        emit(const GroupsLoaded([]));
      }
    } catch (e) {
      emit(GroupError(e.toString()));
    }
  }

  // Créer un groupe simple
  Future<void> _onCreateGroup(
    CreateGroup event,
    Emitter<GroupState> emit,
  ) async {
    try {
      emit(GroupLoading());
      await _repository.createGroupWithMembers(
        group: event.group,
        members: [],
      );
      emit(const GroupOperationSuccess('Groupe créé avec succès'));
    } catch (e) {
      emit(GroupError('Erreur lors de la création: $e'));
    }
  }

  // Créer un groupe avec ses membres
  Future<void> _onCreateGroupWithMembers(
    CreateGroupWithMembers event,
    Emitter<GroupState> emit,
  ) async {
    try {
      emit(GroupLoading());
      await _repository.createGroupWithMembers(
        group: event.group,
        members: event.members,
      );
      emit(const GroupOperationSuccess('Groupe créé avec succès'));
    } catch (e) {
      emit(GroupError('Erreur lors de la création: $e'));
    }
  }

  // Ajouter un membre
  Future<void> _onAddMemberToGroup(
    AddMemberToGroup event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _repository.addMember(event.groupId, event.member);
      emit(const GroupOperationSuccess('Membre ajouté'));
    } catch (e) {
      emit(GroupError('Erreur lors de l\'ajout: $e'));
    }
  }

  // Supprimer un membre
  Future<void> _onRemoveMemberFromGroup(
    RemoveMemberFromGroup event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _repository.removeMember(event.groupId, event.userId);
      emit(const GroupOperationSuccess('Membre supprimé'));
    } catch (e) {
      emit(GroupError('Erreur lors de la suppression: $e'));
    }
  }

  // Mettre à jour un groupe
  Future<void> _onUpdateGroup(
    UpdateGroup event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _repository.updateGroup(event.groupId, event.group);
      emit(const GroupOperationSuccess('Groupe mis à jour'));
    } catch (e) {
      emit(GroupError('Erreur lors de la mise à jour: $e'));
    }
  }

  // Supprimer un groupe
  Future<void> _onDeleteGroup(
    DeleteGroup event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _repository.deleteGroup(event.groupId);
      emit(const GroupOperationSuccess('Groupe supprimé'));
    } catch (e) {
      emit(GroupError('Erreur lors de la suppression: $e'));
    }
  }

  @override
  Future<void> close() {
    _groupsSubscription?.cancel();
    return super.close();
  }
}