find_bloc

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/usecases/get_charge_stations.dart';
import '../../domain/usecases/get_favorite_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,
  })  : _getChargeStations = getChargeStations,
        _openMapsNavigation = openMapsNavigation,
        _loadMarkers = loadMarkers,
        _getFavoriteChargeStations = getFavoriteChargeStations,
        super(const FindInitial()) {
    on<FindEvent>((event, emit) {
      emit(const FindLoading());
    });
    on<GetChargeStationsEvent>(_getChargeStationsHandler);
    on<OpenMapsNavigationEvent>(_openMapsNavigationHandler);
    on<LoadMarkersEvent>(_loadMarkersHandler);
    on<GetFavoriteChargeStationsEvent>(_getFavoriteChargeStationsHandler);
  }

  final GetChargeStations _getChargeStations;
  final OpenMapsNavigation _openMapsNavigation;
  final LoadMarkers _loadMarkers;
  final GetFavoriteChargeStations _getFavoriteChargeStations;

  Future<void> _getChargeStationsHandler(
    GetChargeStationsEvent event,
    Emitter<FindState> emit,
  ) async {
    final result = await _getChargeStations();
    result.fold(
        (failure) =>
            emit(GetChargeStationsError(failure.message, failure.statusCode)),
        (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(FavoriteChargeStationsLoaded(chargeStations)));
  }
}