Untitled

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
import '../../domain/entities/charger_station.dart';
import '../../domain/entities/filter.dart';
import '../../domain/usecases/add_favorite_charge_stations.dart';
import '../../domain/usecases/delete_favorite_charge_station.dart';
import '../../domain/usecases/get_charge_stations.dart';
import '../../domain/usecases/get_favorite_charge_stations.dart';
import '../../domain/usecases/load_filtered_charge_stations.dart';
import '../../domain/usecases/load_markers.dart';
import '../../domain/usecases/open_maps_navigation.dart';

part 'find_state.dart';
part 'find_event.dart';

class FindBloc extends Bloc<FindEvent, FindState> {
  FindBloc({
    required GetChargeStations getChargeStations,
    required OpenMapsNavigation openMapsNavigation,
    required LoadMarkers loadMarkers,
    required GetFavoriteChargeStations getFavoriteChargeStations,
    required AddFavoriteChargeStations addFavoriteChargeStations,
    required DeleteFavoriteChargeStations deleteFavoriteChargeStations,
    required LoadFilteredChargeStations loadFilteredChargeStations,
    // required FilteredChargeStations filteredChargeStations,
  })  : _getChargeStations = getChargeStations,
        _openMapsNavigation = openMapsNavigation,
        _loadMarkers = loadMarkers,
        _getFavoriteChargeStations = getFavoriteChargeStations,
        _addFavoriteChargeStations = addFavoriteChargeStations,
        _deleteFavoriteChargeStations = deleteFavoriteChargeStations,
        _loadFilteredChargeStations = loadFilteredChargeStations,
        // _filteredChargeStations = filteredChargeStations,
        super(const FindInitial()) {
    on<FindEvent>((event, emit) {
      emit(const FindLoading());
    });
    on<GetChargeStationsEvent>(_getChargeStationsHandler);
    on<OpenMapsNavigationEvent>(_openMapsNavigationHandler);
    on<LoadMarkersEvent>(_loadMarkersHandler);
    on<GetFavoriteChargeStationsEvent>(_getFavoriteChargeStationsHandler);
    on<AddFavoriteChargeStationsEvent>(_addFavoriteChargeStationsHandler);
    on<DeleteFavoriteChargeStationsEvent>(_deleteFavoriteChargeStationsHandler);
    on<FilterChargeStationsEvent>(_loadFilteredChargeStationsHandler);
    // on<FilteredChargeStationsEvent>(_filteredChargeStationsHandler);
  }

  final GetChargeStations _getChargeStations;
  final OpenMapsNavigation _openMapsNavigation;
  final LoadMarkers _loadMarkers;
  final GetFavoriteChargeStations _getFavoriteChargeStations;
  final AddFavoriteChargeStations _addFavoriteChargeStations;
  final DeleteFavoriteChargeStations _deleteFavoriteChargeStations;
  final LoadFilteredChargeStations _loadFilteredChargeStations;
  // final FilteredChargeStations _filteredChargeStations;

  Future<void> _getChargeStationsHandler(
    GetChargeStationsEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _getChargeStations();
    result.fold((failure) => emit(GetChargeStationsError(failure.message)),
        (chargeStations) => emit(ChargeStationsLoaded(chargeStations)));
  }

  Future<void> _openMapsNavigationHandler(
    OpenMapsNavigationEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _openMapsNavigation(event.coordinates);
    result.fold((failure) => emit(FindError(failure.message)),
        (_) => emit(const OpenMapsNavigationSuccess()));
  }

  Future<void> _loadMarkersHandler(
    LoadMarkersEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _loadMarkers(event.chargerStations);
    result.fold((failure) => emit(FindError(failure.message)),
        (markers) => emit(MarkersLoaded(markers)));
  }

  Future<void> _getFavoriteChargeStationsHandler(
    GetFavoriteChargeStationsEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _getFavoriteChargeStations(event.userId);
    result.fold(
        (failure) => emit(GetFavoriteChargeStationsError(
            failure.message, failure.statusCode)),
        (chargeStations) =>
            emit(GetFavoriteChargeStationsLoaded(chargeStations)));
  }

  Future<void> _addFavoriteChargeStationsHandler(
    AddFavoriteChargeStationsEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _addFavoriteChargeStations(event.chargerStationId);
    result.fold(
        (failure) => emit(FindError(failure.message)),
        (chargeStationId) =>
            emit(AddFavoriteChargeStationsSuccess(chargeStationId)));
  }

  Future<void> _deleteFavoriteChargeStationsHandler(
    DeleteFavoriteChargeStationsEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _deleteFavoriteChargeStations(event.chargerStationId);
    result.fold(
        (failure) => emit(FindError(failure.message)),
        (chargeStationId) =>
            emit(DeleteFavoriteChargeStationsSuccess(chargeStationId)));
  }

  Future<void> _loadFilteredChargeStationsHandler(
    FilterChargeStationsEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _loadFilteredChargeStations(event.filter);
    result.fold(
        (failure) => emit(FindError(failure.message)),
        (filteredChargeStations) =>
            emit(FilteredChargeStationsLoaded(filteredChargeStations)));
  }
}