import 'dart:developer';

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:equatable/equatable.dart';

import 'package:service_repository/service_repository.dart';

part 'service_event.dart';
part 'service_state.dart';

class ServiceBloc extends Bloc<ServiceEvent, ServiceState> {
  final FirebaseServiceRepository _serviceRepository;

  ServiceBloc({required FirebaseServiceRepository serviceRepository})
      : _serviceRepository = serviceRepository,
        super(CreateServiceInitial()) {
    on<CreateService>(_onCreateService);
    on<LoadService>(_onLoadService);
    on<UpdateServiceStatus>(_onUpdateServiceStatus);
  }

  void _onCreateService(CreateService event, Emitter<ServiceState> emit) async {
    try {
      emit(CreateServiceLoading());

      ServiceEntity service = ServiceEntity(
        professionalId: event.professionalId,
        professionalScored: false,
        userId: event.userId,
        userScored: false,
        address: event.address,
        aditionalAddress: event.aditionalAddress,
        latitude: event.latitude,
        longitude: event.longitude,
        day: event.day,
        createdAt: event.createdAt,
        description: event.description,
        range1Hour1: event.range1Hour1,
        range1Hour2: event.range1Hour2,
        rate: event.rate,
        status: ServiceStatus.pending,
        location: event.location,
      );

      String serviceId = await _serviceRepository.createService(service);

      emit(CreateServiceSuccess(serviceId));
    } catch (e) {
      log(e.toString());
      emit(CreateServiceFailure());
    }
  }

  void _onLoadService(LoadService event, Emitter<ServiceState> emit) async {
    try {
      final serviceStream = _serviceRepository.getService(event.serviceId);

      await for (var service in serviceStream) {
        emit(ServiceLoaded(service));
      }
    } catch (e) {
      log(e.toString());
      emit(CreateServiceFailure());
    }
  }

  void _onUpdateServiceStatus(
      UpdateServiceStatus event, Emitter<ServiceState> emit) async {
    try {
      emit(CreateServiceLoading());
      await _serviceRepository.updateServiceStatus(
          event.serviceId, event.newStatus);
      emit(ServiceStatusUpdated(event.newStatus));
    } catch (e) {
      log(e.toString());
      emit(CreateServiceFailure());
    }
  }
}