TravelMate/lib/services/message_service.dart

import '../models/message.dart';
import '../repositories/message_repository.dart';
import 'error_service.dart';

class MessageService {
  final MessageRepository _messageRepository;
  final ErrorService _errorService;

  MessageService({
    required MessageRepository messageRepository,
    ErrorService? errorService,
  })  : _messageRepository = messageRepository,
        _errorService = errorService ?? ErrorService();

  // Envoyer un message
  Future<void> sendMessage({
    required String groupId,
    required String text,
    required String senderId,
    required String senderName,
  }) async {
    try {
      if (text.trim().isEmpty) {
        throw Exception('Le message ne peut pas être vide');
      }

      await _messageRepository.sendMessage(
        groupId: groupId,
        text: text.trim(),
        senderId: senderId,
        senderName: senderName,
      );
    } catch (e) {
      _errorService.logError(
        'message_service.dart',
        'Erreur lors de l\'envoi du message: $e',
      );
      rethrow;
    }
  }

  // Stream des messages
  Stream<List<Message>> getMessagesStream(String groupId) {
    try {
      return _messageRepository.getMessagesStream(groupId);
    } catch (e) {
      _errorService.logError(
        'message_service.dart',
        'Erreur lors de la récupération des messages: $e',
      );
      rethrow;
    }
  }

  // Supprimer un message
  Future<void> deleteMessage({
    required String groupId,
    required String messageId,
  }) async {
    try {
      await _messageRepository.deleteMessage(
        groupId: groupId,
        messageId: messageId,
      );
    } catch (e) {
      _errorService.logError(
        'message_service.dart',
        'Erreur lors de la suppression du message: $e',
      );
      rethrow;
    }
  }

  // Modifier un message
  Future<void> updateMessage({
    required String groupId,
    required String messageId,
    required String newText,
  }) async {
    try {
      if (newText.trim().isEmpty) {
        throw Exception('Le message ne peut pas être vide');
      }

      await _messageRepository.updateMessage(
        groupId: groupId,
        messageId: messageId,
        newText: newText.trim(),
      );
    } catch (e) {
      _errorService.logError(
        'message_service.dart',
        'Erreur lors de la modification du message: $e',
      );
      rethrow;
    }
  }

  // Ajouter une réaction
  Future<void> reactToMessage({
    required String groupId,
    required String messageId,
    required String userId,
    required String reaction,
  }) async {
    try {
      await _messageRepository.reactToMessage(
        groupId: groupId,
        messageId: messageId,
        userId: userId,
        reaction: reaction,
      );
    } catch (e) {
      _errorService.logError(
        'message_service.dart',
        'Erreur lors de l\'ajout de la réaction: $e',
      );
      rethrow;
    }
  }

  // Supprimer une réaction
  Future<void> removeReaction({
    required String groupId,
    required String messageId,
    required String userId,
  }) async {
    try {
      await _messageRepository.removeReaction(
        groupId: groupId,
        messageId: messageId,
        userId: userId,
      );
    } catch (e) {
      _errorService.logError(
        'message_service.dart',
        'Erreur lors de la suppression de la réaction: $e',
      );
      rethrow;
    }
  }
}