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());
    print('[LOG] Début du chargement des événements pour l\'utilisateur ${event.userId}');

    try {
      final events = await remoteDataSource.getEventsCreatedByUserAndFriends(event.userId);
      print('[LOG] Événements chargés: ${events.length} éléments récupérés.');
      emit(EventLoaded(events));
    } catch (e) {
      print('[ERROR] Erreur lors du chargement des événements: $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()); // 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

        // Émettre un nouvel état avec l'événement mis à jour
        emit(EventLoaded(updatedEvents));
        print('Événement fermé et mis à jour localement.');
      }
    } catch (e) {
      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
    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);

        // 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.');
      }
    } catch (e) {
      // En cas d'erreur, émettre un état d'erreur
      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) {
      // 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);
}