feat: Implement message management features including sending, deleting, updating, and reacting to messages

lib/blocs/message/message_bloc.dart

@@ -0,0 +1,238 @@
+import 'dart:async';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import '../../data/models/message.dart';
+import '../../services/message_service.dart';
+import '../../repositories/message_repository.dart';
+import 'message_event.dart';
+import 'message_state.dart';
+
+class MessageBloc extends Bloc<MessageEvent, MessageState> {
+  final MessageService _messageService;
+  StreamSubscription<List<Message>>? _messagesSubscription;
+
+  MessageBloc({MessageService? messageService})
+      : _messageService = messageService ?? MessageService(
+          messageRepository: MessageRepository(),
+        ),
+        super(MessageInitial()) {
+    on<LoadMessages>(_onLoadMessages);
+    on<SendMessage>(_onSendMessage);
+    on<DeleteMessage>(_onDeleteMessage);
+    on<UpdateMessage>(_onUpdateMessage);
+    on<ReactToMessage>(_onReactToMessage);
+    on<RemoveReaction>(_onRemoveReaction);
+    on<_MessagesUpdated>(_onMessagesUpdated);
+  }
+
+  Future<void> _onLoadMessages(
+    LoadMessages event,
+    Emitter<MessageState> emit,
+  ) async {
+    emit(MessageLoading());
+
+    await _messagesSubscription?.cancel();
+
+    _messagesSubscription = _messageService
+        .getMessagesStream(event.groupId)
+        .listen(
+          (messages) {
+            add(_MessagesUpdated(messages: messages, groupId: event.groupId));
+          },
+          onError: (error) {
+            add(_MessagesError('Erreur lors du chargement des messages: $error'));
+          },
+        );
+  }
+
+  void _onMessagesUpdated(
+    _MessagesUpdated event,
+    Emitter<MessageState> emit,
+  ) {
+    emit(MessagesLoaded(messages: event.messages, groupId: event.groupId));
+  }
+
+  Future<void> _onSendMessage(
+    SendMessage event,
+    Emitter<MessageState> emit,
+  ) async {
+    final currentState = state;
+    
+    try {
+      emit(MessageSending());
+
+      await _messageService.sendMessage(
+        groupId: event.groupId,
+        text: event.text,
+        senderId: event.senderId,
+        senderName: event.senderName,
+      );
+
+      emit(MessageSent());
+      
+      // Retourner à l'état précédent si c'était MessagesLoaded
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    } catch (e) {
+      emit(MessageError('Erreur lors de l\'envoi du message: $e'));
+      
+      // Retourner à l'état précédent
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    }
+  }
+
+  Future<void> _onDeleteMessage(
+    DeleteMessage event,
+    Emitter<MessageState> emit,
+  ) async {
+    final currentState = state;
+    
+    try {
+      emit(MessageDeleting());
+
+      await _messageService.deleteMessage(
+        groupId: event.groupId,
+        messageId: event.messageId,
+      );
+
+      emit(MessageDeleted());
+      
+      // Retourner à l'état précédent si c'était MessagesLoaded
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    } catch (e) {
+      emit(MessageError('Erreur lors de la suppression du message: $e'));
+      
+      // Retourner à l'état précédent
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    }
+  }
+
+  Future<void> _onUpdateMessage(
+    UpdateMessage event,
+    Emitter<MessageState> emit,
+  ) async {
+    final currentState = state;
+    
+    try {
+      emit(MessageUpdating());
+
+      await _messageService.updateMessage(
+        groupId: event.groupId,
+        messageId: event.messageId,
+        newText: event.newText,
+      );
+
+      emit(MessageUpdated());
+      
+      // Retourner à l'état précédent si c'était MessagesLoaded
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    } catch (e) {
+      emit(MessageError('Erreur lors de la modification du message: $e'));
+      
+      // Retourner à l'état précédent
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    }
+  }
+
+  Future<void> _onReactToMessage(
+    ReactToMessage event,
+    Emitter<MessageState> emit,
+  ) async {
+    final currentState = state;
+    
+    try {
+      emit(MessageReacting());
+
+      await _messageService.reactToMessage(
+        groupId: event.groupId,
+        messageId: event.messageId,
+        userId: event.userId,
+        reaction: event.reaction,
+      );
+
+      emit(MessageReacted());
+      
+      // Retourner à l'état précédent si c'était MessagesLoaded
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    } catch (e) {
+      emit(MessageError('Erreur lors de l\'ajout de la réaction: $e'));
+      
+      // Retourner à l'état précédent
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    }
+  }
+
+  Future<void> _onRemoveReaction(
+    RemoveReaction event,
+    Emitter<MessageState> emit,
+  ) async {
+    final currentState = state;
+    
+    try {
+      emit(MessageReacting());
+
+      await _messageService.removeReaction(
+        groupId: event.groupId,
+        messageId: event.messageId,
+        userId: event.userId,
+      );
+
+      emit(MessageReacted());
+      
+      // Retourner à l'état précédent si c'était MessagesLoaded
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    } catch (e) {
+      emit(MessageError('Erreur lors de la suppression de la réaction: $e'));
+      
+      // Retourner à l'état précédent
+      if (currentState is MessagesLoaded) {
+        emit(currentState);
+      }
+    }
+  }
+
+  @override
+  Future<void> close() {
+    _messagesSubscription?.cancel();
+    return super.close();
+  }
+}
+
+// Events internes
+class _MessagesUpdated extends MessageEvent {
+  final List<Message> messages;
+  final String groupId;
+
+  const _MessagesUpdated({
+    required this.messages,
+    required this.groupId,
+  });
+
+  @override
+  List<Object?> get props => [messages, groupId];
+}
+
+class _MessagesError extends MessageEvent {
+  final String error;
+
+  const _MessagesError(this.error);
+
+  @override
+  List<Object?> get props => [error];
+}

lib/blocs/message/message_event.dart

@@ -0,0 +1,94 @@
+import 'package:equatable/equatable.dart';
+
+abstract class MessageEvent extends Equatable {
+  const MessageEvent();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class LoadMessages extends MessageEvent {
+  final String groupId;
+
+  const LoadMessages(this.groupId);
+
+  @override
+  List<Object?> get props => [groupId];
+}
+
+class SendMessage extends MessageEvent {
+  final String groupId;
+  final String text;
+  final String senderId;
+  final String senderName;
+
+  const SendMessage({
+    required this.groupId,
+    required this.text,
+    required this.senderId,
+    required this.senderName,
+  });
+
+  @override
+  List<Object?> get props => [groupId, text, senderId, senderName];
+}
+
+class DeleteMessage extends MessageEvent {
+  final String groupId;
+  final String messageId;
+
+  const DeleteMessage({
+    required this.groupId,
+    required this.messageId,
+  });
+
+  @override
+  List<Object?> get props => [groupId, messageId];
+}
+
+class UpdateMessage extends MessageEvent {
+  final String groupId;
+  final String messageId;
+  final String newText;
+
+  const UpdateMessage({
+    required this.groupId,
+    required this.messageId,
+    required this.newText,
+  });
+
+  @override
+  List<Object?> get props => [groupId, messageId, newText];
+}
+
+class ReactToMessage extends MessageEvent {
+  final String groupId;
+  final String messageId;
+  final String userId;
+  final String reaction;
+
+  const ReactToMessage({
+    required this.groupId,
+    required this.messageId,
+    required this.userId,
+    required this.reaction,
+  });
+
+  @override
+  List<Object?> get props => [groupId, messageId, userId, reaction];
+}
+
+class RemoveReaction extends MessageEvent {
+  final String groupId;
+  final String messageId;
+  final String userId;
+
+  const RemoveReaction({
+    required this.groupId,
+    required this.messageId,
+    required this.userId,
+  });
+
+  @override
+  List<Object?> get props => [groupId, messageId, userId];
+}

lib/blocs/message/message_state.dart

@@ -0,0 +1,51 @@
+import 'package:equatable/equatable.dart';
+import '../../data/models/message.dart';
+
+abstract class MessageState extends Equatable {
+  const MessageState();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class MessageInitial extends MessageState {}
+
+class MessageLoading extends MessageState {}
+
+class MessagesLoaded extends MessageState {
+  final List<Message> messages;
+  final String groupId;
+
+  const MessagesLoaded({
+    required this.messages,
+    required this.groupId,
+  });
+
+  @override
+  List<Object?> get props => [messages, groupId];
+}
+
+class MessageSending extends MessageState {}
+
+class MessageSent extends MessageState {}
+
+class MessageDeleting extends MessageState {}
+
+class MessageDeleted extends MessageState {}
+
+class MessageUpdating extends MessageState {}
+
+class MessageUpdated extends MessageState {}
+
+class MessageReacting extends MessageState {}
+
+class MessageReacted extends MessageState {}
+
+class MessageError extends MessageState {
+  final String message;
+
+  const MessageError(this.message);
+
+  @override
+  List<Object?> get props => [message];
+}