import 'dart:async';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../../services/group_service.dart';
import 'group_event.dart';
import 'group_state.dart';
import '../../data/models/group.dart';

class GroupBloc extends Bloc<GroupEvent, GroupState> {
  final GroupService _groupService;
  StreamSubscription? _groupsSubscription;

  GroupBloc({GroupService? groupService})
      : _groupService = groupService ?? GroupService(),
        super(GroupInitial()) {
    on<GroupLoadRequested>(_onLoadRequested);
    on<_GroupUpdated>(_onGroupUpdated);
    on<GroupCreateRequested>(_onCreateRequested);
    on<GroupUpdateRequested>(_onUpdateRequested);
    on<GroupDeleteRequested>(_onDeleteRequested);
    on<GroupMemberAddRequested>(_onMemberAddRequested);
    on<GroupMemberRemoveRequested>(_onMemberRemoveRequested);
  }

  Future<void> _onLoadRequested(
    GroupLoadRequested event,
    Emitter<GroupState> emit,
  ) async {
    emit(GroupLoading());

    await _groupsSubscription?.cancel();
    
    _groupsSubscription = _groupService.getGroupsStreamByUser(event.userId).listen(
      (groups) => add(_GroupUpdated(groups: groups)),
      onError: (error) => emit(GroupError(message: error.toString())),
    );
  }

  Future<void> _onGroupUpdated(
    _GroupUpdated event,
    Emitter<GroupState> emit,
  ) async {
    emit(GroupLoaded(groups: event.groups));
  }

  Future<void> _onCreateRequested(
    GroupCreateRequested event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _groupService.createGroup(event.group);
      emit(const GroupOperationSuccess(message: 'Groupe créé avec succès'));
    } catch (e) {
      emit(GroupError(message: e.toString()));
    }
  }

  Future<void> _onUpdateRequested(
    GroupUpdateRequested event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _groupService.updateGroup(event.group);
      emit(const GroupOperationSuccess(message: 'Groupe mis à jour'));
    } catch (e) {
      emit(GroupError(message: e.toString()));
    }
  }

  Future<void> _onDeleteRequested(
    GroupDeleteRequested event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _groupService.deleteGroup(event.groupId);
      emit(const GroupOperationSuccess(message: 'Groupe supprimé'));
    } catch (e) {
      emit(GroupError(message: e.toString()));
    }
  }

  Future<void> _onMemberAddRequested(
    GroupMemberAddRequested event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _groupService.addMemberToGroup(event.groupId, event.memberId);
      emit(const GroupOperationSuccess(message: 'Membre ajouté'));
    } catch (e) {
      emit(GroupError(message: e.toString()));
    }
  }

  Future<void> _onMemberRemoveRequested(
    GroupMemberRemoveRequested event,
    Emitter<GroupState> emit,
  ) async {
    try {
      await _groupService.removeMemberFromGroup(event.groupId, event.memberId);
      emit(const GroupOperationSuccess(message: 'Membre retiré'));
    } catch (e) {
      emit(GroupError(message: e.toString()));
    }
  }

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

// Événement interne pour les mises à jour du stream
class _GroupUpdated extends GroupEvent {
  final List<Group> groups;

  const _GroupUpdated({required this.groups});

  @override
  List<Object?> get props => [groups];
}