import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:unit2/model/profile/basic_info.dart';
import 'package:unit2/model/profile/basic_information/primary-information.dart';
import 'package:unit2/model/profile/eligibility.dart';
import 'package:unit2/model/profile/profileInfomation.dart';
import 'package:unit2/model/utils/eligibility.dart';
import 'package:unit2/sevices/profile/eligibility_services.dart';
import 'package:unit2/sevices/profile/profile_service.dart';
import 'package:unit2/test_data.dart';
import 'package:unit2/utils/location_utilities.dart';
import 'package:unit2/utils/profile_utilities.dart';
import '../../model/location/country.dart';
import '../../model/location/region.dart';
import '../../model/location/provinces.dart';
import '../../model/location/city.dart';
import '../../model/location/barangay.dart';
part 'profile_event.dart';
part 'profile_state.dart';

class ProfileBloc extends Bloc<ProfileEvent, ProfileState> {
  ProfileBloc() : super(ProfileInitial()) {
    ProfileInformation? _profileInformation;
    List<Country>? _countries;
    List<Region>? _regions;
    List<Eligibility>? _eligibilities;
    List<Province>? _provinces;
    List<CityMunicipality>? _cities;
    ////=========================================================================
    on<LoadProfile>((event, emit) async {
      // try {
      emit(ProfileLoading());
      ProfileInformation? profileInformation =
          await ProfileService.instance.getProfile(event.token, event.userID);
      _profileInformation = profileInformation;
      emit(ProfileLoaded(profileInformation: _profileInformation!));
      // } catch (e) {
      //   emit(ProfileErrorState(mesage: e.toString()));
      // }
    });
////=====================================================================
    on<LoadEligibility>((event, emit) {
      emit(ProfileLoading());
      emit(EligibilityLoaded(eligibilities: event.eligibilities));
    });
////====================================================================
    on<EditEligibility>((event, emit) async {
      Region? currentRegion;
      Province? currentProvince;
      CityMunicipality? currentCity;
      // try{
      emit(ProfileLoading());
      if (_countries == null) {
        List<Country> countries = await LocationUtils.instance.getCountries();
        _countries = countries;
      }
      if (_regions == null) {
        List<Region> regions = await LocationUtils.instance.getRegions();
        _regions = regions;
      }
      if (_eligibilities == null) {
        List<Eligibility> eligibilities =
            await ProfileUtilities.instance.getEligibilities();
        _eligibilities = eligibilities;
      }

// get current country
      Country? currentCountry = _countries!.firstWhere((Country country) =>
          country.code == event.eligibityCert.examAddress?.country!.code);
// get current eligibility
      Eligibility currentEligibility = _eligibilities!.firstWhere(
          (Eligibility eligibility) =>
              event.eligibityCert.eligibility!.id == eligibility.id);

      bool? isOverseas = event.eligibityCert.overseas;

      if (event.selectedRegion != null) {
        if (event.selectedProvince == null) {
          currentRegion = event.selectedRegion;
          List<Province> provinces = await LocationUtils.instance
              .getProvinces(regionCode: event.selectedRegion!.code.toString());
          _provinces = provinces;
          currentProvince = null;
          currentCity = null;
        }
        if (event.selectedProvince != null) {
          currentRegion = event.selectedRegion;
          List<Province> provinces = await LocationUtils.instance
              .getProvinces(regionCode: event.selectedRegion!.code.toString());
          _provinces = provinces;
          currentProvince = _provinces!.firstWhere(
              (Province p) => event.selectedProvince!.code == p.code);
          List<CityMunicipality> citymuns = await LocationUtils.instance
              .getCities(code: currentProvince.code.toString());
          _cities = citymuns;
          currentCity = null;
        }
      } else {
        // if exam address region is not equal to null get the region, provinces and citymunicipalities
        if (event.eligibityCert.examAddress?.cityMunicipality?.province
                ?.region !=
            null) {
          currentRegion = _regions!.firstWhere((Region r) =>
              event.eligibityCert.examAddress!.cityMunicipality!.province!
                  .region!.code ==
              r.code);

          List<Province> provinces = await LocationUtils.instance.getProvinces(
              regionCode: event.eligibityCert.examAddress!.cityMunicipality!
                  .province!.region!.code!
                  .toString());
          _provinces = provinces;

          currentProvince = _provinces!.firstWhere((Province p) =>
              event.eligibityCert.examAddress!.cityMunicipality!.province!
                  .code ==
              p.code);
          List<CityMunicipality> citymuns = await LocationUtils.instance
              .getCities(
                  code: event.eligibityCert.examAddress!.cityMunicipality!
                      .province!.code!);
          _cities = citymuns;

          currentCity = _cities!.firstWhere((CityMunicipality c) =>
              event.eligibityCert.examAddress!.cityMunicipality!.code ==
              c.code);
        }
      }
      emit(EditEligibilityState(
          isOverseas: isOverseas!,
          currentEligibility: currentEligibility,
          currentCountry: currentCountry,
          currentRegion: currentRegion,
          currentCity: currentCity,
          cityMuns: _cities,
          provinces: _provinces,
          eligibityCert: event.eligibityCert,
          countries: _countries!,
          regions: _regions!,
          currentProvince: currentProvince,
          eligibilities: _eligibilities!));

      // }catch(e){
      //   emit(ProfileErrorState(mesage: e.toString()));
      // }

      ////====================================================================
    });
    on<AddEligibility>((event, emit) async {
      Region? currentRegion;
      Province? currentProvince;
      CityMunicipality? currentCity;
      List<CityMunicipality>? cities;
      List<Province>? provinces;
      Eligibility? currentEligibility;
      final bool overseas = event.overseas;
      emit(ProfileLoading());
      if (_regions == null) {
        List<Region> regions = await LocationUtils.instance.getRegions();
        _regions = regions;
      }
      if (_eligibilities == null) {
        List<Eligibility> eligibilities =
            await ProfileUtilities.instance.getEligibilities();
        _eligibilities = eligibilities;
      }
      if (_countries == null) {
        List<Country> countries = await LocationUtils.instance.getCountries();
        _countries = countries;
      }

      if(event.selectedEligibility != null){
        currentEligibility = _eligibilities!.firstWhere((Eligibility element) => element.id == event.selectedEligibility!.id);
      }else{
        currentEligibility = null;
      }
      if (event.selectedRegion != null) {
        if (event.selectedProvince == null) {
          currentRegion = event.selectedRegion;
          provinces = await LocationUtils.instance
              .getProvinces(regionCode: event.selectedRegion!.code.toString());
              _provinces = provinces;
          currentProvince = null;
          currentCity = null;
        }
        if (event.selectedProvince != null) {
          currentRegion = event.selectedRegion;
          provinces = await LocationUtils.instance
              .getProvinces(regionCode: event.selectedRegion!.code.toString());
          _provinces = provinces;
          currentProvince = _provinces!.firstWhere(
              (Province p) => event.selectedProvince!.code == p.code);
          cities = await LocationUtils.instance
              .getCities(code: currentProvince.code.toString());
          _cities = cities;
          currentCity = null;
        }
      }else{
        print("executed");
        currentRegion = null;
        currentProvince = null;
        currentCity = null;
        _provinces = null;
        _cities = null;
      }

      emit(AddEligibilityState(
          cities: cities,
          provinces: provinces,
          currentEligibility: currentEligibility,
          currentRegion: overseas? null: currentRegion,
          currentProvince: currentProvince,
          overseas: overseas,
          eligibilities: _eligibilities!,
          regions: _regions!,
          countries: _countries!));
    });
    ////====================================================================
    on<DeleteEligibility>((event, emit) async {
      emit(ProfileLoading());
      try {
        final bool success = await EligibilityService.instance.delete(
            eligibilityId: event.eligibilityId,
            profileId: int.parse(event.profileId),
            token: event.token);
        if (success) {
          event.eligibilities.removeWhere(
              ((EligibityCert element) => element.id == event.eligibilityId));
          List<EligibityCert> eligibilities = event.eligibilities;
          emit(DeletedState(success: success, eligibilities: eligibilities));
        } else {
          emit(DeletedState(
              success: success, eligibilities: event.eligibilities));
        }
      } catch (e) {
        emit(ProfileErrorState(mesage: e.toString()));
      }
    });
  }
}