fix(chat): Correction race condition + Implémentation TODOs

## Corrections Critiques

### Race Condition - Statuts de Messages
- Fix : Les icônes de statut (✓, ✓✓, ✓✓ bleu) ne s'affichaient pas
- Cause : WebSocket delivery confirmations arrivaient avant messages locaux
- Solution : Pattern Optimistic UI dans chat_bloc.dart
  - Création message temporaire immédiate
  - Ajout à la liste AVANT requête HTTP
  - Remplacement par message serveur à la réponse
- Fichier : lib/presentation/state_management/chat_bloc.dart

## Implémentation TODOs (13/21)

### Social (social_header_widget.dart)
- ✅ Copier lien du post dans presse-papiers
- ✅ Partage natif via Share.share()
- ✅ Dialogue de signalement avec 5 raisons

### Partage (share_post_dialog.dart)
- ✅ Interface sélection d'amis avec checkboxes
- ✅ Partage externe via Share API

### Média (media_upload_service.dart)
- ✅ Parsing JSON réponse backend
- ✅ Méthode deleteMedia() pour suppression
- ✅ Génération miniature vidéo

### Posts (create_post_dialog.dart, edit_post_dialog.dart)
- ✅ Extraction URL depuis uploads
- ✅ Documentation chargement médias

### Chat (conversations_screen.dart)
- ✅ Navigation vers notifications
- ✅ ConversationSearchDelegate pour recherche

## Nouveaux Fichiers

### Configuration
- build-prod.ps1 : Script build production avec dart-define
- lib/core/constants/env_config.dart : Gestion environnements

### Documentation
- TODOS_IMPLEMENTED.md : Documentation complète TODOs

## Améliorations

### Architecture
- Refactoring injection de dépendances
- Amélioration routing et navigation
- Optimisation providers (UserProvider, FriendsProvider)

### UI/UX
- Amélioration thème et couleurs
- Optimisation animations
- Meilleure gestion erreurs

### Services
- Configuration API avec env_config
- Amélioration datasources (events, users)
- Optimisation modèles de données

lib/presentation/state_management/event_bloc.dart

@@ -1,85 +1,127 @@
+import 'package:equatable/equatable.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:meta/meta.dart';
-import 'package:afterwork/data/models/event_model.dart';
-import 'package:afterwork/data/datasources/event_remote_data_source.dart';
+
+import '../../core/utils/app_logger.dart';
+import '../../data/datasources/event_remote_data_source.dart';
+import '../../data/models/event_model.dart';
 
 // Déclaration des événements
 @immutable
-abstract class EventEvent {}
+abstract class EventEvent extends Equatable {
+  const EventEvent();
+
+  @override
+  List<Object?> get props => [];
+}
 
 class LoadEvents extends EventEvent {
+  const LoadEvents(this.userId);
+
   final String userId;
-  LoadEvents(this.userId);
+
+  @override
+  List<Object?> get props => [userId];
 }
 
 class AddEvent extends EventEvent {
+  const AddEvent(this.event);
+
   final EventModel event;
 
-  AddEvent(this.event);
+  @override
+  List<Object?> get props => [event];
 }
 
 class CloseEvent extends EventEvent {
+  const CloseEvent(this.eventId);
+
   final String eventId;
 
-  CloseEvent(this.eventId);
+  @override
+  List<Object?> get props => [eventId];
 }
 
 class ReopenEvent extends EventEvent {
+  const ReopenEvent(this.eventId);
+
   final String eventId;
 
-  ReopenEvent(this.eventId);
+  @override
+  List<Object?> get props => [eventId];
 }
 
 // Déclaration des états
 @immutable
-abstract class EventState {}
+abstract class EventState extends Equatable {
+  const EventState();
 
-class EventInitial extends EventState {}
+  @override
+  List<Object?> get props => [];
+}
 
-class EventLoading extends EventState {}
+class EventInitial extends EventState {
+  const EventInitial();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class EventLoading extends EventState {
+  const EventLoading();
+
+  @override
+  List<Object?> get props => [];
+}
 
 class EventLoaded extends EventState {
+  const EventLoaded(this.events);
+
   final List<EventModel> events;
 
-  EventLoaded(this.events);
+  @override
+  List<Object?> get props => [events];
 }
 
 class EventError extends EventState {
+  const EventError(this.message);
+
   final String message;
 
-  EventError(this.message);
+  @override
+  List<Object?> get props => [message];
 }
 
 // Bloc pour la gestion des événements
 class EventBloc extends Bloc<EventEvent, EventState> {
-  final EventRemoteDataSource remoteDataSource;
 
-  EventBloc({required this.remoteDataSource}) : super(EventInitial()) {
+  EventBloc({required this.remoteDataSource}) : super(const EventInitial()) {
     on<LoadEvents>(_onLoadEvents);
     on<AddEvent>(_onAddEvent);
     on<CloseEvent>(_onCloseEvent);
     on<ReopenEvent>(_onReopenEvent);
     on<RemoveEvent>(_onRemoveEvent); // Ajout du gestionnaire pour RemoveEvent
   }
+  final EventRemoteDataSource remoteDataSource;
 
   // Gestion du chargement des événements
   Future<void> _onLoadEvents(LoadEvents event, Emitter<EventState> emit) async {
-    emit(EventLoading());
-    print('[LOG] Début du chargement des événements pour l\'utilisateur ${event.userId}');
+    emit(const EventLoading());
+    AppLogger.i('Début du chargement des événements pour l\'utilisateur ${event.userId}', tag: 'EventBloc');
 
     try {
       final events = await remoteDataSource.getEventsCreatedByUserAndFriends(event.userId);
-      print('[LOG] Événements chargés: ${events.length} éléments récupérés.');
+      AppLogger.i('Événements chargés: ${events.length} éléments récupérés.', tag: 'EventBloc');
       emit(EventLoaded(events));
-    } catch (e) {
-      print('[ERROR] Erreur lors du chargement des événements: $e');
+    } catch (e, stackTrace) {
+      AppLogger.e('Erreur lors du chargement des événements', error: e, stackTrace: stackTrace, tag: 'EventBloc');
       emit(EventError('Erreur lors du chargement des événements.'));
     }
   }
 
   // Gestion de l'ajout d'un nouvel événement
   Future<void> _onAddEvent(AddEvent event, Emitter<EventState> emit) async {
-    emit(EventLoading());
+    emit(const EventLoading());
     try {
       await remoteDataSource.createEvent(event.event);
       final events = await remoteDataSource.getAllEvents();
@@ -91,65 +133,83 @@ class EventBloc extends Bloc<EventEvent, EventState> {
 
   // Gestion de la fermeture d'un événement
   Future<void> _onCloseEvent(CloseEvent event, Emitter<EventState> emit) async {
-    emit(EventLoading()); // Affiche le chargement
+    final currentState = state; // Sauvegarder l'état actuel avant d'émettre EventLoading
+    emit(const EventLoading()); // Affiche le chargement
     try {
       await remoteDataSource.closeEvent(event.eventId);
 
       // Mise à jour de l'événement spécifique dans l'état
-      if (state is EventLoaded) {
-        final updatedEvents = List<EventModel>.from((state as EventLoaded).events);
-        final updatedEvent = updatedEvents.firstWhere((e) => e.id == event.eventId);
-        updatedEvent.status = 'fermé';  // Modifier l'état de l'événement localement
+      if (currentState is EventLoaded) {
+        final updatedEvents = List<EventModel>.from((currentState as EventLoaded).events);
+        try {
+          final updatedEvent = updatedEvents.firstWhere((e) => e.id == event.eventId);
+          updatedEvent.status = 'fermé';  // Modifier l'état de l'événement localement
 
-        // Émettre un nouvel état avec l'événement mis à jour
-        emit(EventLoaded(updatedEvents));
-        print('Événement fermé et mis à jour localement.');
+          // Émettre un nouvel état avec l'événement mis à jour
+          emit(EventLoaded(updatedEvents));
+          AppLogger.i('Événement fermé et mis à jour localement.', tag: 'EventBloc');
+        } catch (_) {
+          // Événement non trouvé, restaurer l'état précédent
+          emit(currentState);
+        }
       }
-    } catch (e) {
+    } catch (e, stackTrace) {
+      AppLogger.e('Erreur lors de la fermeture de l\'événement', error: e, stackTrace: stackTrace, tag: 'EventBloc');
       emit(EventError('Erreur lors de la fermeture de l\'événement.'));
-      print('Erreur lors de la fermeture de l\'événement : $e');
     }
   }
 
   Future<void> _onReopenEvent(ReopenEvent event, Emitter<EventState> emit) async {
-    emit(EventLoading()); // Affiche le chargement
+    final currentState = state; // Sauvegarder l'état actuel avant d'émettre EventLoading
+    emit(const EventLoading()); // Affiche le chargement
     try {
       // Appel au service backend pour réouvrir l'événement
       await remoteDataSource.reopenEvent(event.eventId);
 
       // Mise à jour de l'événement spécifique dans l'état
-      if (state is EventLoaded) {
-        final updatedEvents = List<EventModel>.from((state as EventLoaded).events);
-        final updatedEvent = updatedEvents.firstWhere((e) => e.id == event.eventId);
+      if (currentState is EventLoaded) {
+        final updatedEvents = List<EventModel>.from((currentState as EventLoaded).events);
+        try {
+          final updatedEvent = updatedEvents.firstWhere((e) => e.id == event.eventId);
 
-        // Mise à jour du statut local de l'événement
-        updatedEvent.status = 'ouvert';
+          // Mise à jour du statut local de l'événement
+          updatedEvent.status = 'ouvert';
 
-        // Émettre un nouvel état avec l'événement mis à jour
-        emit(EventLoaded(updatedEvents));
-        print('Événement réouvert et mis à jour localement.');
+          // Émettre un nouvel état avec l'événement mis à jour
+          emit(EventLoaded(updatedEvents));
+          AppLogger.i('Événement réouvert et mis à jour localement.', tag: 'EventBloc');
+        } catch (_) {
+          // Événement non trouvé, restaurer l'état précédent
+          emit(currentState);
+        }
       }
-    } catch (e) {
+    } catch (e, stackTrace) {
       // En cas d'erreur, émettre un état d'erreur
+      AppLogger.e('Erreur lors de la réouverture de l\'événement', error: e, stackTrace: stackTrace, tag: 'EventBloc');
       emit(EventError('Erreur lors de la réouverture de l\'événement.'));
-      print('Erreur lors de la réouverture de l\'événement : $e');
     }
   }
 
   // Gestion de la suppression locale d'un événement
   Future<void> _onRemoveEvent(RemoveEvent event, Emitter<EventState> emit) async {
-    if (state is EventLoaded) {
+    final currentState = state; // Sauvegarder l'état actuel
+    if (currentState is EventLoaded) {
       // Supprimer l'événement de la liste locale sans recharger tout
-      final List<EventModel> updatedEvents = List.from((state as EventLoaded).events)
+      final List<EventModel> updatedEvents = List.from((currentState as EventLoaded).events)
         ..removeWhere((e) => e.id == event.eventId);
+      // Toujours émettre le nouvel état, même si la liste est identique
+      // (car removeWhere peut ne rien faire si l'événement n'existe pas)
       emit(EventLoaded(updatedEvents));
     }
   }
 }
 
 class RemoveEvent extends EventEvent {
+  const RemoveEvent(this.eventId);
+
   final String eventId;
 
-  RemoveEvent(this.eventId);
+  @override
+  List<Object?> get props => [eventId];
 }