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';

// Déclaration des événements
@immutable
abstract class EventEvent {}

class LoadEvents extends EventEvent {
  final String userId;
  LoadEvents(this.userId);
}

class AddEvent extends EventEvent {
  final EventModel event;

  AddEvent(this.event);
}

class CloseEvent extends EventEvent {
  final String eventId;

  CloseEvent(this.eventId);
}

class ReopenEvent extends EventEvent {
  final String eventId;

  ReopenEvent(this.eventId);
}

// Déclaration des états
@immutable
abstract class EventState {}

class EventInitial extends EventState {}

class EventLoading extends EventState {}

class EventLoaded extends EventState {
  final List<EventModel> events;

  EventLoaded(this.events);
}

class EventError extends EventState {
  final String message;

  EventError(this.message);
}

// Bloc pour la gestion des événements
class EventBloc extends Bloc<EventEvent, EventState> {
  final EventRemoteDataSource remoteDataSource;

  EventBloc({required this.remoteDataSource}) : super(EventInitial()) {
    on<LoadEvents>(_onLoadEvents);
    on<AddEvent>(_onAddEvent);
    on<CloseEvent>(_onCloseEvent);
    on<ReopenEvent>(_onReopenEvent);
    on<RemoveEvent>(_onRemoveEvent); // Ajout du gestionnaire pour RemoveEvent
  }

  // Gestion du chargement des événements
  Future<void> _onLoadEvents(LoadEvents event, Emitter<EventState> emit) async {
    emit(EventLoading());
    try {
      final events = await remoteDataSource.getAllEvents();
      emit(EventLoaded(events));
    } catch (e) {
      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());
    try {
      await remoteDataSource.createEvent(event.event);
      final events = await remoteDataSource.getAllEvents();
      emit(EventLoaded(events));
    } catch (e) {
      emit(EventError('Erreur lors de l\'ajout de l\'événement.'));
    }
  }

  // Gestion de la fermeture d'un événement
  Future<void> _onCloseEvent(CloseEvent event, Emitter<EventState> emit) async {
    emit(EventLoading());
    try {
      await remoteDataSource.closeEvent(event.eventId);
      final events = await remoteDataSource.getAllEvents();
      emit(EventLoaded(events));
    } catch (e) {
      emit(EventError('Erreur lors de la fermeture de l\'événement.'));
    }
  }

  // Gestion de la réouverture d'un événement
  Future<void> _onReopenEvent(ReopenEvent event, Emitter<EventState> emit) async {
    emit(EventLoading());
    try {
      await remoteDataSource.reopenEvent(event.eventId);
      final events = await remoteDataSource.getAllEvents();
      emit(EventLoaded(events));
    } catch (e) {
      emit(EventError('Erreur lors de la réouverture de l\'événement.'));
    }
  }

  // Gestion de la suppression locale d'un événement
  Future<void> _onRemoveEvent(RemoveEvent event, Emitter<EventState> emit) async {
    if (state is EventLoaded) {
      // Supprimer l'événement de la liste locale sans recharger tout
      final List<EventModel> updatedEvents = List.from((state as EventLoaded).events)
        ..removeWhere((e) => e.id == event.eventId);
      emit(EventLoaded(updatedEvents));
    }
  }
}

class RemoveEvent extends EventEvent {
  final String eventId;

  RemoveEvent(this.eventId);
}

