HMG_Patient_App_New/lib/features/authentication/authentication_view_model.dart

import 'dart:convert';
import 'dart:developer';
import 'package:flutter/services.dart' show rootBundle;
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/cache_consts.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/request_models/registration_payload_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/presentation/authentication/saved_login_screen.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/localauth_service.dart';
import 'package:hmg_patient_app_new/services/navigation_service.dart';

import 'models/request_models/insert_patient_mobile_deviceinfo.dart';
import 'models/request_models/patient_insert_device_imei_request.dart';

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

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

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

  NationalityCountries? pickedCountryByUAEUser;
  CalenderEnum calenderType = CalenderEnum.gregorian;
  LoginTypeEnum loginTypeEnum = LoginTypeEnum.sms;

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

  String errorMsg = '';
  final FocusNode myFocusNode = FocusNode();
  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();
  }

  Future<void> loadCountriesData() async {
    final String response = await rootBundle.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();
  }

  bool isUserFromUAE() {
    bool isFromUAE = false;
    if (_appState.getUserRegistrationPayload.patientOutSa != 0) {
      isFromUAE = true;
    }
    return isFromUAE;
  }

  void savePushTokenToAppState() async {
    _appState.deviceToken = await Utils.getStringFromPrefs(CacheConst.pushToken);
  }

  Future<void> selectDeviceImei({required Function(dynamic data) onSuccess, Function(String)? onError}) async {
    // LoadingUtils.showFullScreenLoading();
    // String firebaseToken = _appState.deviceToken;
    String firebaseToken = await Utils.getStringFromPrefs(CacheConst.pushToken);
    // == ""
    // ? "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);
        LoadingUtils.hideFullScreenLoader();
        _navigationService.pushPage(page: LoginScreen());
      },
      (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());
      }
    } 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());
          // _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

    loginTypeEnum = otpTypeEnum == OTPTypeEnum.sms ? LoginTypeEnum.sms : LoginTypeEnum.whatsapp;

    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.setAppAuthToken = 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: null, //todo silent login case halded on the repo itself..
              );
            }
          }
        }
      },
    );
  }

  Future<void> sendActivationCode({required OTPTypeEnum otpTypeEnum, required String nationalIdOrFileNumber, required String phoneNumber, dynamic payload}) async {
    bool isForRegister = checkIsUserComingForRegister(request: payload);
    bool isPatientOutSA = isPatientOutsideSA(request: payload);
    bool isFileNo = 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);
          }
        }
      },
    );
  }

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

  Future<void> checkActivationCode({
    required String? 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.appAuthToken,
      registeredData: null,
      nationIdText: nationalIdController.text,
      countryCode: selectedCountrySignup.countryCode,
      loginType:  loginTypeEnum.toInt
    ).toJson();

    bool isForRegister =  (_appState.getUserRegistrationPayload.healthId != null || _appState.getUserRegistrationPayload.patientOutSa == true);
    if (isForRegister) {
      if (_appState.getUserRegistrationPayload.patientOutSa == true) request['DOB'] = _appState.getUserRegistrationPayload.dob;
      request['HealthId'] = _appState.getUserRegistrationPayload.healthId;
      request['IsHijri'] = _appState.getUserRegistrationPayload.isHijri;

      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 (_appState.getUserRegistrationPayload.isRegister == true) {
          //TODO: KSA Version Came Hre
          loadCountriesData();
          _navigationService.pushAndReplace(AppRoutes.registerStepTwo);
          // Navigator.popUntil(context, (route) => Utils.route(route, equalsTo: RegisterNew));
          return;
        }
      });
    } else {
      final resultEither = await _authenticationRepo.checkActivationCodeRepo(
        newRequest: CheckActivationCodeRegisterReq.fromJson(request),
        activationCode: activationCode,
        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 (activation.messageStatus == 2) {
          onWrongActivationCode(activation.errorEndUserMessage);
          return;
        } else if (_appState.getUserRegistrationPayload.isRegister == true) {
          _navigationService.pushAndReplace(AppRoutes.registerStepTwo);
          // 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.setAppAuthToken = activation.authenticationTokenId;
          final request = RequestUtils.getAuthanticatedCommonRequest().toJson();
          bool isUserAgreedBefore = await checkIfUserAgreedBefore(request: request);
          insertPatientIMEIData(loginTypeEnum.toInt);
          clearDefaultInputValues();
          if (isUserAgreedBefore) {
            navigateToHomeScreen();
          } else {
            navigateToHomeScreen();
            //Agreement page not designed yet so we are navigating to home screen directly
            // 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.toString(),
            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 {
    await _dialogService.showErrorBottomSheet(message: message ?? "Something went wrong. ", onOkPressed: () {});
  }

  loginWithFingerPrintFace() async {
    _localAuthService.authenticate().then((value) async {
      if (value) {
        // we have to handle this if verification true;
        if(!_appState.isAuthenticated) {
          loginTypeEnum = (_appState.deviceTypeID == 1 ? LoginTypeEnum.face : LoginTypeEnum.fingerprint);
          print(loginTypeEnum);
           checkActivationCode(otpTypeEnum:OTPTypeEnum.faceIDFingerprint , activationCode: null, onWrongActivationCode: (String? message) {});
          insertPatientIMEIData((_appState.deviceTypeID == 1 ? LoginTypeEnum.face.toInt : LoginTypeEnum.fingerprint.toInt));
        }else {
          // authenticated = true;
          insertPatientIMEIData((_appState.deviceTypeID == 1 ? LoginTypeEnum.face.toInt : LoginTypeEnum.fingerprint.toInt));
        }

        notifyListeners();
        // navigateToHomeScreen();
      } else {
        //authenticated = false;
        notifyListeners();
      }
    });
  }

  checkLastLoginStatus(Function() onSuccess) async {
    Future.delayed(Duration(seconds: 1), () {
    if (_appState.getSelectDeviceByImeiRespModelElement != null &&
        (_appState.getSelectDeviceByImeiRespModelElement!.logInType == 1 || _appState.getSelectDeviceByImeiRespModelElement!.logInType == 4)) {
      phoneNumberController.text = (_appState.getAuthenticatedUser()!.mobileNumber!.startsWith("0")
            ? _appState.getAuthenticatedUser()!.mobileNumber!.replaceFirst("0", "")
            : _appState.getAuthenticatedUser()!.mobileNumber)!;
        nationalIdController.text = _appState.getAuthenticatedUser()!.nationalityId!;
        onSuccess();
        }   else if((loginTypeEnum == LoginTypeEnum.sms || loginTypeEnum == LoginTypeEnum.whatsapp && _appState.getSelectDeviceByImeiRespModelElement == null) && _appState.getAuthenticatedUser() != null){
          phoneNumberController.text = (_appState.getAuthenticatedUser()!.mobileNumber!.startsWith("0")
          ? _appState.getAuthenticatedUser()!.mobileNumber!.replaceFirst("0", "")
          : _appState.getAuthenticatedUser()!.mobileNumber)!;
      nationalIdController.text = _appState.getAuthenticatedUser()!.nationalityId!;
      onSuccess();
    }
    });
  }

  Future<void> onRegistrationStart({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> onRegistrationComplete() async{

    // if (emailAddress.text.isEmpty) {
    //   Utils.showErrorToast(TranslationBase.of(context).enterEmailAddress);
    //   return;
    // } else {
    //   Navigator.of(context).pop();
    //   registerNow();
    // }
    //authVM!.clearDefaultInputValues();
  }


  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 (isPatientOutsideSA(request: response)) {
          print("=======OUT SA=======");
          _appState.setAppAuthToken = response['LogInTokenID'];
          sendActivationCode(
              otpTypeEnum: OTPTypeEnumExtension.fromInt(request["OTP_SendType"]),
              nationalIdOrFileNumber: request["PatientIdentificationID"].toString(),
              phoneNumber: request["PatientMobileNumber"].toString());
        } else {
          print("=======IN SA=======");
          chekUserNHICData(request: request);
        }
      }
    } else {
      //TODO: Here Hide Loader And Show TOAST
      //TODO: if (response['ErrorCode'] == '-986') Toast With OK, And Show response as Output.
    }
  }

  bool isPatientOutsideSA({required dynamic request}) {
    bool isOutSideSa = false;
    if (request is Map<String, dynamic> && request.containsKey("PatientOutSA")) {
      if (request["PatientOutSA"] == true) {
        isOutSideSa = true;
      } else {
        isOutSideSa = false;
      }
    }
    print(isOutSideSa);
    return isOutSideSa;
  }

  bool isPatientHasFile({required dynamic request}) {
    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) {
        setNHICData(apiResponse.data, request);
        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();
    //       },
    //     ),
    //   );
    // });
  }

  void setNHICData(dynamic data, dynamic request) {
    _appState.setNHICUserData = CheckUserStatusResponseNHIC.fromJson(data as Map<String, dynamic>);
    request["healthId"] = _appState.getNHICUserData.healthId;
    _appState.setUserRegistrationPayload = RegistrationDataModelPayload.fromJson(request);
  }

    Future<void>  insertPatientIMEIData(int loginType) async{

      final resultEither = await _authenticationRepo.insertPatientIMEIData(patientIMEIDataRequest: PatientInsertDeviceImei(imei: _appState.deviceToken, deviceTypeId: _appState.getDeviceTypeID(), patientId: _appState.getAuthenticatedUser()!.patientId!, patientIdentificationNo:_appState.getAuthenticatedUser()!.nationalityId!, firstName:  _appState.getAuthenticatedUser()!.firstName!,  lastName:  _appState.getAuthenticatedUser()!.lastName!, patientTypeId: _appState.getAuthenticatedUser()!.patientType, mobileNo:_appState.getAuthenticatedUser()!.mobileNumber!, logInTypeId: loginType, patientOutSa:_appState.getAuthenticatedUser()!.outSa!, outSa: _appState.getAuthenticatedUser()!.outSa == 1 ? true :false, biometricEnabled: loginType == 1 || loginType ==2 ? false :true, firstNameN:_appState.getAuthenticatedUser()!.firstNameN , lastNameN:_appState.getAuthenticatedUser()!.lastNameN ).toJson());
      resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) async {
        if (apiResponse.messageStatus == 1) {
          log("Insert IMEI Success");
          insertPatientDeviceData( loginType);
        } else {
          log("Insert IMEI Failed");
        }
      });

    }
  Future<void>  insertPatientDeviceData(int loginType) async{

    final resultEither = await _authenticationRepo.insertPatientDeviceData(patientDeviceDataRequest: InsertPatientMobileDeviceInfo(deviceToken: _appState.deviceToken, deviceTypeId: _appState.getDeviceTypeID(), patientId: _appState.getAuthenticatedUser()!.patientId!,  patientTypeId: _appState.getAuthenticatedUser()!.patientType,  patientOutSa:_appState.getAuthenticatedUser()!.outSa!, loginType:  loginType, languageId: _appState.getLanguageID(), latitude: _appState.userLat, longitude:_appState.userLong, voipToken: "", deviceType: _appState.deviceTypeID, patientMobileNumber:_appState.getAuthenticatedUser()!.mobileNumber, nationalId:  _appState.getAuthenticatedUser()!.patientIdentificationNo, gender:  _appState.getAuthenticatedUser()!.gender ).toJson());
    resultEither.fold((failure) async => await _errorHandlerService.handleError(failure: failure), (apiResponse) async {
      if (apiResponse.messageStatus == 1) {
        log("Insert Device Data Success");
      } else {
        log("Insert IMEI Failed");
      }
    });

  }

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