TravelMate/lib/blocs/trip/trip_bloc.dart

import 'dart:async';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../../repositories/trip_repository.dart';
import 'trip_event.dart';
import 'trip_state.dart';
import '../../data/models/trip.dart';

class TripBloc extends Bloc<TripEvent, TripState> {
  final TripRepository _tripRepository;
  StreamSubscription? _tripsSubscription;

  TripBloc({required TripRepository tripRepository})
      : _tripRepository = tripRepository,
        super(TripInitial()) {
    on<TripLoadRequested>(_onLoadRequested);
    on<TripCreateRequested>(_onCreateRequested);
    on<TripUpdateRequested>(_onUpdateRequested);
    on<TripDeleteRequested>(_onDeleteRequested);
    on<TripParticipantAddRequested>(_onParticipantAddRequested);
    on<TripParticipantRemoveRequested>(_onParticipantRemoveRequested);
  }

  Future<void> _onLoadRequested(
    TripLoadRequested event,
    Emitter<TripState> emit,
  ) async {
    emit(TripLoading());

    await _tripsSubscription?.cancel();
    
    _tripsSubscription = _tripRepository.getUserTrips(event.userId).listen(
      (trips) => add(const _TripUpdated(trips: [])), // Sera géré par un événement interne
      onError: (error) => emit(TripError(message: error.toString())),
    );
  }

  Future<void> _onCreateRequested(
    TripCreateRequested event,
    Emitter<TripState> emit,
  ) async {
    try {
      await _tripRepository.createTrip(event.trip);
      emit(const TripOperationSuccess(message: 'Voyage créé avec succès'));
    } catch (e) {
      emit(TripError(message: e.toString()));
    }
  }

  Future<void> _onUpdateRequested(
    TripUpdateRequested event,
    Emitter<TripState> emit,
  ) async {
    try {
      await _tripRepository.updateTrip(event.trip);
      emit(const TripOperationSuccess(message: 'Voyage mis à jour'));
    } catch (e) {
      emit(TripError(message: e.toString()));
    }
  }

  Future<void> _onDeleteRequested(
    TripDeleteRequested event,
    Emitter<TripState> emit,
  ) async {
    try {
      await _tripRepository.deleteTrip(event.tripId);
      emit(const TripOperationSuccess(message: 'Voyage supprimé'));
    } catch (e) {
      emit(TripError(message: e.toString()));
    }
  }

  Future<void> _onParticipantAddRequested(
    TripParticipantAddRequested event,
    Emitter<TripState> emit,
  ) async {
    try {
      await _tripRepository.addParticipant(
        event.tripId,
        event.participantEmail,
      );
      emit(const TripOperationSuccess(message: 'Participant ajouté'));
    } catch (e) {
      emit(TripError(message: e.toString()));
    }
  }

  Future<void> _onParticipantRemoveRequested(
    TripParticipantRemoveRequested event,
    Emitter<TripState> emit,
  ) async {
    try {
      await _tripRepository.removeParticipant(
        event.tripId,
        event.participantEmail,
      );
      emit(const TripOperationSuccess(message: 'Participant retiré'));
    } catch (e) {
      emit(TripError(message: e.toString()));
    }
  }

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

// Événement interne pour les mises à jour du stream
class _TripUpdated extends TripEvent {
  final List<Trip> trips;

  const _TripUpdated({required this.trips});

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