HMG_Patient_App_New/lib/features/authentication/authentication_view_model.dart

import 'dart:convert';
import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:hijri_gregorian_calendar/hijri_gregorian_calendar.dart';
import 'package:hmg_patient_app_new/core/app_state.dart';
import 'package:hmg_patient_app_new/core/common_models/nationality_country_model.dart';
import 'package:hmg_patient_app_new/core/enums.dart';
import 'package:hmg_patient_app_new/core/utils/loading_utils.dart';
import 'package:hmg_patient_app_new/core/utils/request_utils.dart';
import 'package:hmg_patient_app_new/core/utils/utils.dart';
import 'package:hmg_patient_app_new/core/utils/validation_utils.dart';
import 'package:hmg_patient_app_new/extensions/string_extensions.dart';
import 'package:hmg_patient_app_new/features/authentication/authentication_repo.dart';
import 'package:hmg_patient_app_new/features/authentication/models/request_models/check_activation_code_register_request_model.dart';
import 'package:hmg_patient_app_new/features/authentication/models/resp_models/check_activation_code_resp_model.dart';
import 'package:hmg_patient_app_new/features/authentication/models/resp_models/check_user_staus_nhic_response_model.dart';
import 'package:hmg_patient_app_new/features/authentication/models/resp_models/select_device_by_imei.dart';
import 'package:hmg_patient_app_new/presentation/authentication/login.dart';
import 'package:hmg_patient_app_new/routes/app_routes.dart';
import 'package:hmg_patient_app_new/services/cache_service.dart';
import 'package:hmg_patient_app_new/services/dialog_service.dart';
import 'package:hmg_patient_app_new/services/error_handler_service.dart';
import 'package:hmg_patient_app_new/services/navigation_service.dart';

import 'models/resp_models/authenticated_user_resp_model.dart';

class AuthenticationViewModel extends ChangeNotifier {
  final AuthenticationRepo _authenticationRepo;
  final AppState _appState;
  final ErrorHandlerService _errorHandlerService;
  final DialogService _dialogService;
  final NavigationService _navigationService;

  AuthenticationViewModel({
    required AppState appState,
    required AuthenticationRepo authenticationRepo,
    required ErrorHandlerService errorHandlerService,
    required DialogService dialogService,
    required NavigationService navigationService,
    required CacheService cacheService,
  })  : _navigationService = navigationService,
        _dialogService = dialogService,
        _errorHandlerService = errorHandlerService,
        _appState = appState,
        _authenticationRepo = authenticationRepo;

  final TextEditingController nationalIdController = TextEditingController(), phoneNumberController = TextEditingController(), dobController = TextEditingController();
  CountryEnum selectedCountrySignup = CountryEnum.saudiArabia;
  MaritalStatusTypeEnum? maritalStatus;
  GenderTypeEnum? genderType;
  bool isTermsAccepted = false;
  List<NationalityCountries>? countriesList;
  String? dob = "";

  NationalityCountries? pickedCountryByUAEUser;
  CalenderEnum calenderType = CalenderEnum.gregorian;

  //==================

  bool isDubai = false;
  bool authenticated = false;
  late int mobileNumber;
  String errorMsg = '';
  var registerd_data;
  bool isMoreOption = false;
  var zipCode;
  var patientOutSA;
  var loginTokenID;
  var loginType;
  var deviceToken;
  var lastLogin;
  final FocusNode myFocusNode = FocusNode();
  late int selectedOption = 1;
  bool onlySMSBox = false;
  int fingrePrintBefore = 0;

  var healthId;

  Future<void> onLoginPressed() async {
    try {
      LoadingUtils.showFullScreenLoader();
      //TODO:  We will remove this delay
      await Future.delayed(Duration(seconds: 3));
      var data = _appState.getSelectDeviceByImeiRespModelElement;
      log("Cached IMEI data: ${data?.toJson()}");
      if (data != null) {
        await _handleExistingImeiData(data);
      } else {
        await _handleNewImeiRegistration();
      }
    } catch (e) {
      log("Error in onLoginPressed: $e");
      LoadingUtils.hideFullScreenLoader();
      _dialogService.showErrorBottomSheet(message: "An unexpected error occurred. Please try again.", onOkPressed: () {});
    }
  }

  void clearDefaultInputValues() {
    nationalIdController.clear();
    phoneNumberController.clear();
    dobController.clear();
    maritalStatus = null;
    genderType = null;
    isTermsAccepted = false;
    selectedCountrySignup = CountryEnum.saudiArabia;
    pickedCountryByUAEUser = null;
  }

  void onCountryChange(CountryEnum country) {
    selectedCountrySignup = country;
    notifyListeners();
  }

  void onCalenderTypeChange(bool isGregorian) {
    calenderType = isGregorian ? CalenderEnum.gregorian : CalenderEnum.hijri;
    notifyListeners();
  }

  void onDobChange(String? date) {
    if (calenderType == CalenderEnum.hijri) {
      var hijriDate = HijriGregConverter.gregorianToHijri(DateTime.parse(date!));
      DateTime hijriDateTimeForController = DateTime(hijriDate.year, hijriDate.month, hijriDate.day);
      dob = Utils.formatDateForApi(date);
      dobController.text = Utils.formatHijriDateToDisplay(hijriDateTimeForController.toIso8601String()); // Or directly hijriDate.toString() if that's what your formatter expects
    } else {
      dobController.text = Utils.formatDateToDisplay(date!);
      dob = Utils.formatDateForApi(date);
    }
    notifyListeners();
  }

  void loadCountriesData({required BuildContext context}) async {
    final String response = await DefaultAssetBundle.of(context).loadString('assets/json/countriesList.json');
    final List<dynamic> data = json.decode(response);
    countriesList = data.map((e) => NationalityCountries.fromJson(e)).toList();
  }

  void onMaritalStatusChange(String? status) {
    maritalStatus = MaritalStatusTypeExtension.fromType(status)!;
    notifyListeners();
  }

  void onGenderChange(String? status) {
    genderType = GenderTypeExtension.fromType(status)!;
    notifyListeners();
  }

  void onUAEUserCountrySelection(String? value) {
    pickedCountryByUAEUser = countriesList!.firstWhere((element) => element.name == value);
    notifyListeners();
  }

  void onPhoneNumberChange(String? phoneNumber) {
    phoneNumberController.text = phoneNumber!;
  }

  void onTermAccepted() {
    isTermsAccepted = !isTermsAccepted;
    notifyListeners();
  }

  Future<void> selectDeviceImei({required Function(dynamic data) onSuccess, Function(String)? onError}) async {
    // LoadingUtils.showFullScreenLoading();
    String firebaseToken = _appState.deviceToken == ""
        ? "dOGRRszQQMGe_9wA5Hx3kO:APA91bFV5IcIJXvcCXXk0tc2ddtZgWwCPq7sGSuPr-YW7iiJpQZKgFGN9GAzCVOWL8MfheaP1slE8MdxB7lczdPBGdONQ7WbMmhgHcsUCUktq-hsapGXXqc"
        : _appState.deviceToken;
    final result = await _authenticationRepo.selectDeviceByImei(firebaseToken: firebaseToken);

    result.fold(
      (failure) async {
        // LoadingUtils.hideFullScreenLoader();
        await _errorHandlerService.handleError(failure: failure);
      },
      (apiResponse) {
        // LoadingUtils.hideFullScreenLoader();
        log("apiResponse: ${apiResponse.data.toString()}");
        log("messageStatus: ${apiResponse.messageStatus.toString()}");
        if (apiResponse.messageStatus == 1) {
          onSuccess(apiResponse.data);
        } else if (apiResponse.messageStatus == 2) {
          _dialogService.showErrorBottomSheet(message: "Message Status = 2", onOkPressed: () {});
        }
      },
    );
  }

  Future<void> _handleExistingImeiData(dynamic data) async {
    try {
      SelectDeviceByImeiRespModelElement? savedData = _appState.getSelectDeviceByImeiRespModelElement;
      LoadingUtils.hideFullScreenLoader();

      if (savedData != null) {
        // TODO: Navigate to SavedLogin when available
        _navigationService.pushPage(page: LoginScreen());
        // navigationService.pushPage(page: SavedLogin(savedData));
      }
    } catch (e) {
      log("Error handling existing IMEI data: $e");
      LoadingUtils.hideFullScreenLoader();
      _navigationService.pushPage(page: LoginScreen());
    }
  }

  Future<void> _handleNewImeiRegistration() async {
    await selectDeviceImei(onSuccess: (dynamic respData) async {
      try {
        if (respData != null) {
          dynamic data = SelectDeviceByImeiRespModelElement.fromJson(respData.toJson());
          _appState.setSelectDeviceByImeiRespModelElement(data);
          LoadingUtils.hideFullScreenLoader();

          // TODO: Navigate to SavedLogin when available
          // SelectDeviceByImeiRespModelElement savedData =
          //     SelectDeviceByImeiRespModelElement.fromJson(respData);
          // navigationService.pushPage(page: SavedLogin(savedData));
          _navigationService.pushPage(page: LoginScreen());
        } else {
          LoadingUtils.hideFullScreenLoader();
          _navigationService.pushPage(page: LoginScreen());
        }
      } catch (e) {
        log("Error processing IMEI registration response: $e");
        LoadingUtils.hideFullScreenLoader();
        _navigationService.pushPage(page: LoginScreen());
      }
    }, onError: (String error) {
      LoadingUtils.hideFullScreenLoader();
      _dialogService.showErrorBottomSheet(message: error, onOkPressed: () {});
    });
  }

  Future<void> checkUserAuthentication({required OTPTypeEnum otpTypeEnum, Function(dynamic)? onSuccess, Function(String)? onError}) async {
    // TODO: THIS SHOULD BE REMOVED LATER ON AND PASSED FROM APP STATE DIRECTLY INTO API CLIENT. BECAUSE THIS API ONLY NEEDS FEW PARAMS FROM USER

    if (phoneNumberController.text.isEmpty) {
      phoneNumberController.text = "504278212";
    }
    bool isValidated = ValidationUtils.isValidatePhoneAndId(
      phoneNumber: phoneNumberController.text,
      nationalId: nationalIdController.text,
    );

    if (!isValidated) {
      return;
    }

    LoadingUtils.showFullScreenLoader();

    dynamic checkPatientAuthenticationReq = RequestUtils.getPatientAuthenticationRequest(
        phoneNumber: phoneNumberController.text,
        nationId: nationalIdController.text,
        isForRegister: false,
        patientOutSA: false,
        otpTypeEnum: otpTypeEnum,
        patientId: 0,
        zipCode: selectedCountrySignup.countryCode,
        calenderType: calenderType);

    final result = await _authenticationRepo.checkPatientAuthentication(checkPatientAuthenticationReq: checkPatientAuthenticationReq);
    LoadingUtils.hideFullScreenLoader();
    result.fold(
      (failure) async => await _errorHandlerService.handleError(failure: failure),
      (apiResponse) async {
        if (apiResponse.messageStatus == 2) {
          await _dialogService.showErrorBottomSheet(message: apiResponse.errorMessage ?? "ErrorEmpty", onOkPressed: () {});
        } else if (apiResponse.messageStatus == 1) {
          if (apiResponse.data['isSMSSent']) {
            _appState.setAppLoginTokenID = apiResponse.data['LogInTokenID'];
            sendActivationCode(
              otpTypeEnum: otpTypeEnum,
              phoneNumber: phoneNumberController.text,
              nationalIdOrFileNumber: nationalIdController.text,
            );
          } else {
            if (apiResponse.data['IsAuthenticated']) {
              await checkActivationCode(
                otpTypeEnum: otpTypeEnum,
                onWrongActivationCode: (String? message) {},
                activationCode: 0000,
              );
            }
          }
        }
      },
    );
  }

  Future<void> sendActivationCode({required OTPTypeEnum otpTypeEnum, required String nationalIdOrFileNumber, required String phoneNumber, dynamic payload}) async {
    bool isForRegister = await checkIsUserComingForRegister(request: payload);
    bool isPatientOutSA = await isPatientOutsideSA(request: payload);
    bool isFileNo = await isPatientHasFile(request: payload);

    var request = RequestUtils.getCommonRequestSendActivationCode(
        otpTypeEnum: otpTypeEnum,
        mobileNumber: phoneNumber,
        selectedLoginType: otpTypeEnum.toInt(),
        zipCode: selectedCountrySignup.countryCode,
        nationalId: int.parse(nationalIdOrFileNumber),
        isFileNo: isFileNo,
        patientId: 0,
        isForRegister: isForRegister,
        patientOutSA: isPatientOutSA,
        payload: payload);

    // TODO: GET APP SMS SIGNATURE HERE
    request.sMSSignature = "enKTDcqbOVd";
    // GifLoaderDialogUtils.showMyDialog(context);

    // bool isForRegister = healthId != null || isDubai;
    // if (isForRegister) {
    //   if (!isDubai) {
    //     request.dob = dob; //isHijri == 1 ? dob : dateFormat2.format(dateFormat.parse(dob));
    //   }
    //   request.healthId = healthId;
    //   request.isHijri = calenderType.toInt;
    // } else {
    //   // request.dob = "";
    //   // request.healthId = "";
    //   // request.isHijri = 0;
    // }

    final resultEither = await _authenticationRepo.sendActivationCodeRepo(sendActivationCodeReq: request, isRegister: isForRegister, languageID: 'er');

    resultEither.fold(
      (failure) async => await _errorHandlerService.handleError(failure: failure),
      (apiResponse) async {
        if (apiResponse.messageStatus == 2) {
          await _dialogService.showErrorBottomSheet(message: apiResponse.errorMessage ?? "ErrorEmpty");
        } else {
          if (apiResponse.data != null && apiResponse.data['isSMSSent'] == true) {
            navigateToOTPScreen(otpTypeEnum: otpTypeEnum, phoneNumber: phoneNumber);
          } else {
            // TODO: Handle isSMSSent false
            // navigateToOTPScreen(otpTypeEnum: otpTypeEnum, phoneNumber: phoneNumber);
          }
        }
      },
    );
  }

  Future<bool> checkIsUserComingForRegister({required dynamic request}) async {
    bool isUserComingForRegister = false;
    print(request);
    if (request != null && request['isRegister']) {
      isUserComingForRegister = true;
    }
    return isUserComingForRegister;
  }

  Future<void> checkActivationCode({
    required int activationCode,
    required OTPTypeEnum otpTypeEnum,
    required Function(String? message) onWrongActivationCode,
  }) async {
    final request = RequestUtils.getCommonRequestWelcome(
      phoneNumber: phoneNumberController.text,
      otpTypeEnum: otpTypeEnum,
      deviceToken: _appState.deviceToken,
      patientOutSA: true,
      loginTokenID: _appState.appLoginTokenID,
      registeredData: null,
      nationIdText: nationalIdController.text,
      countryCode: selectedCountrySignup.countryCode,
    ).toJson();

    bool isForRegister = healthId != null || isDubai;
    if (isForRegister) {
      if (isDubai) request['DOB'] = dob;
      request['HealthId'] = healthId;
      request['IsHijri'] = calenderType.toInt;

      final resultEither = await _authenticationRepo.checkActivationCodeRepo(newRequest: request, activationCode: activationCode.toString(), isRegister: true);

      resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) {
        final activation = CheckActivationCode.fromJson(apiResponse.data as Map<String, dynamic>);
        if (registerd_data?.isRegister == true) {
          _navigationService.popUntilNamed(AppRoutes.registerNewScreen);
          // Navigator.popUntil(context, (route) => Utils.route(route, equalsTo: RegisterNew));
          return;
        }
      });
    } else {
      final resultEither = await _authenticationRepo.checkActivationCodeRepo(
        newRequest: CheckActivationCodeRegisterReq.fromJson(request),
        activationCode: activationCode.toString(),
        isRegister: false,
      );

      resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) async {
        final activation = CheckActivationCode.fromJson(apiResponse.data as Map<String, dynamic>);
        if (activation.errorCode == '699') {
          // Todo: Hide Loader
          // GifLoaderDialogUtils.hideDialog(context);
          onWrongActivationCode(activation.errorEndUserMessage);
          return;
        } else if (registerd_data?.isRegister == true) {
          _navigationService.popUntilNamed(AppRoutes.registerNewScreen);
          // Navigator.popUntil(context, (route) => Utils.route(route, equalsTo: RegisterNew));
          return;
        } else {
          if (activation.list != null && activation.list!.isNotEmpty) {
            _appState.setAuthenticatedUser(activation.list!.first);
          }
          _appState.setUserBloodGroup = (activation.patientBlodType ?? "");
          _appState.setAppLoginTokenID = activation.authenticationTokenId;
          final request = RequestUtils.getAuthanticatedCommonRequest().toJson();
          bool isUserAgreedBefore = await checkIfUserAgreedBefore(request: request);
          clearDefaultInputValues();
          if (isUserAgreedBefore) {
            navigateToHomeScreen();
          } else {
            getUserAgreementContent(request: request);
          }
          // TODO: setPreferences and stuff
          // sharedPref.remove(FAMILY_FILE);
          // activation.list!.isFamily = false;
          // userData = activation.list;
          // sharedPref.setString(BLOOD_TYPE, activation.patientBloodType ?? "");
          // authenticatedUserObject.user = activation.list!;
          // projectViewModel.setPrivilege(privilegeList: res);
          // await sharedPref.setObject(MAIN_USER, activation.list);
          // await sharedPref.setObject(USER_PROFILE, activation.list);
          // loginTokenID = activation.logInTokenID;
          // await sharedPref.setObject(LOGIN_TOKEN_ID, activation.logInTokenID);
          // await sharedPref.setString(TOKEN, activation.authenticationTokenID!);

          // projectViewModel.analytics.loginRegistration.login_successful();
        }
      });
    }
  }

  Future<bool> checkIfUserAgreedBefore({required dynamic request}) async {
    bool isAgreed = false;
    if (havePrivilege(109)) {
      final resultEither = await _authenticationRepo.checkIfUserAgreed(commonAuthanticatedRequest: request);
      resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) {
        if (apiResponse.data['IsPatientAlreadyAgreed']) {
          return true;
        }
      });
    }
    return isAgreed;
  }

  Future<void> getUserAgreementContent({required dynamic request}) async {
    final resultEither = await _authenticationRepo.getUserAgreementContent(commonAuthanticatedRequest: request);
    resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) async {
      // _navigationService.pushAndReplace(routeName)
      //TODO: Add User Agreement Page Here
    });
  }

  bool havePrivilege(int id) {
    bool isHavePrivilege = false;
    try {
      for (var element in _appState.getAuthenticatedUser()!.listPrivilege!) {
        if (element.id == id) isHavePrivilege = element.previlege!;
      }
    } catch (e) {
      print(e);
    }
    return isHavePrivilege;
  }

  Future<void> navigateToHomeScreen() async {
    _navigationService.pushAndReplace(AppRoutes.landingScreen);
  }

  Future<void> navigateToOTPScreen({required OTPTypeEnum otpTypeEnum, required String phoneNumber}) async {
    _navigationService.pushToOtpScreen(
      phoneNumber: phoneNumber,
      checkActivationCode: (int activationCode) async {
        await checkActivationCode(
            activationCode: activationCode,
            otpTypeEnum: otpTypeEnum,
            onWrongActivationCode: (String? value) {
              onWrongActivationCode(message: value);
            });

        // Navigator.of(context).push(MaterialPageRoute(builder: (BuildContext context) => RegisterNewStep2(null, {"nationalID": "12345678654321"})));
      },
      onResendOTPPressed: (String phoneNumber) {},
    );
  }

  Future<void> onWrongActivationCode({String? message}) async {
    // TODO: HANDLE THIS VIA BOTTOM SHEET
  }

  Future<void> onRegisterPress({required OTPTypeEnum otpTypeEnum}) async {
    bool isOutSidePatient = selectedCountrySignup.countryCode == CountryEnum.unitedArabEmirates.countryCode ? true : false;

    final request = await RequestUtils.getPatientAuthenticationRequest(
            phoneNumber: phoneNumberController.text,
            nationId: nationalIdController.text,
            patientOutSA: isOutSidePatient,
            otpTypeEnum: otpTypeEnum,
            isForRegister: true,
            patientId: 0,
            zipCode: selectedCountrySignup.countryCode,
            calenderType: calenderType,
            dob: dob)
        .toJson();
    var nRequest = Map<String, dynamic>.from(request);

    if (true) {
      request.removeWhere((key, value) => value == null);
      nRequest.removeWhere((key, value) => value == null);
      nRequest.removeWhere((key, value) => key == "SearchType");
      nRequest.removeWhere((key, value) => key == "PatientID");
      nRequest.removeWhere((key, value) => key == "OTP_SendType");
      nRequest.removeWhere((key, value) => key == "LanguageID");
    }

    final resultEither = await _authenticationRepo.checkPatientForRegistration(commonAuthanticatedRequest: nRequest);
    resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) async {
      checkUserStatusForRegistration(response: apiResponse.data, request: request);
    });
  }

  Future<void> checkUserStatusForRegistration({required dynamic response, required dynamic request}) async {
    if (response is Map) {
      _appState.setAppAuthToken = response["LogInTokenID"];
      if (response["MessageStatus"] == 2) {
        print(response["ErrorEndUserMessage"]);
        return;
      }
      if (response['hasFile'] == true) {
        //TODO: Show Here Ok And Cancel Dialog and On OKPress it will go for sendActivationCode
      } else {
        request['forRegister'] = true;
        request['isRegister'] = true;
        if (await isPatientOutsideSA(request: response)) {
          print("=======IN SA=======");
          chekUserNHICData(request: request);
        } else {
          print("=======OUT SA=======");
          _appState.setAppLoginTokenID = response['LogInTokenID'];
          sendActivationCode(
              otpTypeEnum: OTPTypeEnumExtension.fromInt(request["OTP_SendType"]),
              nationalIdOrFileNumber: request["PatientIdentificationID"].toString(),
              phoneNumber: request["PatientMobileNumber"].toString());
        }
      }
    } else {
      //TODO: Here Hide Loader And Show TOAST
      //TODO: if (response['ErrorCode'] == '-986') Toast With OK, And Show response as Output.
    }
  }

  Future<bool> isPatientOutsideSA({required dynamic request}) {
    try {
      if (request is Map<String, dynamic> && request.containsKey("PatientOutSA")) {
        if (!request["PatientOutSA"]) {
          return Future.value(true);
        } else {
          return Future.value(false);
        }
      } else {
        return Future.value(false);
      }
    } catch (e) {
      return Future.value(false);
    }
  }

  Future<bool> isPatientHasFile({required dynamic request}) async {
    bool isFile = false;
    if (request != null && request["NationalID"] != null) {
      isFile = request["NationalID"].length < 10;
    }
    return isFile;
  }

  Future<void> chekUserNHICData({required dynamic request}) async {
    final resultEither = await _authenticationRepo.checkUserStatus(commonAuthanticatedRequest: request);
    resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) async {
      if (apiResponse.data is Map) {
        _appState.setNHICUserData = CheckUserStatusResponseNHIC.fromJson(apiResponse.data as Map<String, dynamic>);
        sendActivationCode(
          otpTypeEnum: OTPTypeEnumExtension.fromInt(request["OTP_SendType"]),
          nationalIdOrFileNumber: request["PatientIdentificationID"].toString(),
          phoneNumber: request["PatientMobileNumber"].toString(),
          payload: request,
        );
      }
    });

    // this.authService.checkUserStatus(request).then((result) {
    //   // Keep loader active, continue to next step
    //   if (result is Map) {
    //     RegisterInfoResponse? resultSet;
    //     CheckUserStatusResponse res = CheckUserStatusResponse.fromJson(result as Map<String, dynamic>);
    //     nHICData = res;
    //     sharedPref.setObject(NHIC_DATA, res.toJson());
    //     resultSet = RegisterInfoResponse.fromJson(res.toJson());
    //
    //     sendActivationCode(type, loginToken, resultSet, isSkipRegistration);
    //   } else {
    //     GifLoaderDialogUtils.hideDialog(context);
    //     context.showBottomSheet(
    //       child: ExceptionBottomSheet(
    //         message: result != null ? result : TranslationBase.of(context).somethingWentWrong,
    //         showCancel: false,
    //         onOkPressed: () {
    //           Navigator.of(context).pop();
    //         },
    //       ),
    //     );
    //   }
    // }).catchError((err) {
    //   GifLoaderDialogUtils.hideDialog(context);
    //   context.showBottomSheet(
    //     child: ExceptionBottomSheet(
    //       message: err.toString(),
    //       showCancel: false,
    //       onOkPressed: () {
    //         Navigator.of(context).pop();
    //       },
    //     ),
    //   );
    // });
  }

  @override
  void dispose() {
    nationalIdController.dispose();
    phoneNumberController.dispose();
    myFocusNode.dispose();
    super.dispose();
  }
}