prosappco/lib/blocs/professional_bloc/professional_bloc.dart

import 'dart:developer';

import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:professional_repository/professional_repository.dart';
import 'package:prosappco/blocs/professional_list_bloc/professional_list_bloc.dart';
import 'package:user_repository/user_repository.dart';

part 'professional_event.dart';
part 'professional_state.dart';

class ProfessionalBloc extends Bloc<ProfessionalEvent, ProfessionalState> {
  final ApiProfessionalRepository _professionalRepository;
  final UserRepository _userRepository;

  ProfessionalBloc(
      {required ApiProfessionalRepository professionalRepository,
      required UserRepository userRepository})
      : _professionalRepository = professionalRepository,
        _userRepository = userRepository,
        super(ProfessionalInitial()) {
    bool isProModeActive = _professionalRepository.isProModeActive;
    final proInfo = _professionalRepository.lastProInfo();
    emit(LoadedModeProState(isProModeActive, proInfo));
    if (isProModeActive && proInfo == null) {
      _fetchMyProInfo();
    }

    _professionalRepository.streamProInfo().listen((proInfo) {
      if (proInfo == null) {
        emit(const ProfessionalStateFailure());
      } else {
        final isProModeActive = _professionalRepository.isProModeActive;
        emit(LoadedModeProState(isProModeActive, proInfo));
      }
    });

    _professionalRepository.sreamIsProModeActive().listen((isProModeActive) {
      add(UpdateProfessionalEvent(isProModeActive: isProModeActive));
    });

    on<SwitchProModeEvent>((event, emit) async {
      await _professionalRepository.switchProMode();
    });

    on<ResetProfessionalApplicationEvent>((event, emit) async {
      emit(ResetProfessionalApplicationLoading());
      try {
        await _professionalRepository.deleteProfessionalInfo();
        emit(ResetProfessionalApplicationSuccess());
      } catch (e) {
        log(e.toString());
        emit(ProfessionalStateFailure(message: e.toString()));
      }
    });

    on<UpdateProfessionalEvent>((event, emit) async {
      final proInfo = _professionalRepository.lastProInfo();
      emit(LoadedModeProState(event.isProModeActive, proInfo));
      if (event.isProModeActive && proInfo == null) {
        await _fetchMyProInfo();
      }
    });

    on<SendProfessionalToReviewEvent>((event, emit) async {
      emit(SendProfessionalToReviewLoading());
      final myUser = await _userRepository.lastUser();
      if (myUser == null) {
        emit(const SendProfessionalToReviewFailure(
            message: 'No se pudo identificar tu usuario'));
        return;
      }
      try {
        final identificationPdfUrl = await _professionalRepository
            .uploadPdfCedula(event.identificationPicture, myUser.id);

        final certificatePdfUrl = await _professionalRepository
            .uploadPdfCertificado(event.certificatePicture, myUser.id);

        List<String> specializationsPdfUrls = [];
        if (event.specializationsPictures.isNotEmpty) {
          specializationsPdfUrls =
              await _professionalRepository.uploadPdfsEspecializaciones(
                  event.specializationsPictures, myUser.id);
        } else {
          specializationsPdfUrls = [];
        }

        await _professionalRepository.saveProfessionalInfo(ProfessionalEntity(
          id: event.id,
          identification: event.identification,
          identificationPicture: identificationPdfUrl,
          address: '',
          aditionalAddress: '',
          profession: event.profession,
          specializations: event.specializations,
          specializationsPictures: specializationsPdfUrls,
          certificatePicture: certificatePdfUrl,
          latitude: 0,
          longitude: 0,
          ratePreferences: false,
          rate: '',
          locationPreferences: LocationPreferences.office,
          bannerPicture: '',
          schedules: Schedules.empty,
          paymentMethods: PaymentMethodEntity.empty,
        ));

        emit(SendProfessionalToReviewSuccess());
      } catch (e) {
        log('error acceso a pro ${e.toString()}');
        emit(SendProfessionalToReviewFailure(message: e.toString()));
      }
    });
  }

  Future<void> _fetchMyProInfo() async {
    final myUser = await _userRepository.lastUser();
    if (myUser == null) return;
    await _professionalRepository.updateFromFirebase(userId: myUser.id);
  }
}