import 'dart:convert';
import 'dart:io';

import 'package:wanisclient/providers/utils_provider.dart';
import 'package:wanisclient/providers/utils_singleton.dart';
import 'package:device_info_plus/device_info_plus.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/material.dart';
import 'package:fluttertoast/fluttertoast.dart';
import 'package:get/get.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:get_it/get_it.dart';
import 'dart:developer';
import 'package:http/http.dart' as http;

import '../config/AppSnackbar.dart';
import '../config/api_response.dart';
import '../config/constants/MessageTranslation.dart';
import '../config/language/language_enum.dart';
import '../models/login_response.dart';
import '../models/users.dart';
import '../screens/allow_location_screen.dart';
import '../screens/login_screnn.dart';
import '../services/auth_services.dart';
import '../utils/connection.dart';
import 'language_provider.dart';

class AuthProvider extends ChangeNotifier {
  AuthServices get authService => GetIt.I<AuthServices>();
  bool loader = false;
  bool _logoutloading = false;
  String deviceId = "";
  String deviceModel = "";
  String ipAddress = "";
  String deviceType = "";
  users? profile;
  VoidCallback? onValidate;
  String dToken = "";
  String? _email;


  String get emailAddress => _email ?? '';

  bool get logoutloading => _logoutloading;

  // SharedPreferences instance cached for reuse
  late final SharedPreferences _prefs;

  AuthProvider() {
    _init();
  }

  Future<void> _init() async {
    _prefs = await SharedPreferences.getInstance();
  }

  Future<void> getLoginData(BuildContext context) async {
    final utilProvider = context.read<UtilsProvider>();
    if (Platform.isIOS) {
      deviceId = utilProvider.deviceInfo['name'];
      deviceModel = utilProvider.deviceInfo['model'];
      ipAddress = utilProvider.ipAddress;
    } else {
      deviceId = utilProvider.deviceInfo['id'];
      deviceModel = utilProvider.deviceInfo['model'];
      ipAddress = utilProvider.ipAddress;
    }
  }

  Future<bool> updateProfile(Map<String, dynamic> updatedFields) async {
    _updateLoaderStatus(true);
    print('*-*-*-*-*-*--------------------------------$updatedFields');
    if (!await Connection.checkConnection()) {
      log("No Internet Connection");
      _updateLoaderStatus(false);
      return false;
    }

    try {
      final updateResult = await authService.updateProfile(updatedFields);

      if (updateResult.statusCode == 200 || updateResult.statusCode == 201) {
        await fetchProfile(); // ✅ Await this
        notifyListeners();
        AppSnackbar.showSuccess("Success", "Profile updated successfully");
        return true;
      } else {
        log("Failed to update profile with status code: ${updateResult.statusCode}");
        return false;
      }
    } catch (e, stackTrace) {
      log("Provider updateProfile caught error: $e");
      log("Error stack trace: $stackTrace");
      AppSnackbar.showError("Error", "Profile updated unsuccessfully");

      return false;
    } finally {
      _updateLoaderStatus(false); // ✅ Guaranteed to run
    }
  }
 Future<bool> sendsimplesmsverification(String phonenumber) async {

     if (!await Connection.checkConnection()) {
      log("No Internet Connection");
      _updateLoaderStatus(false);
      return false;
    }

    try {
      final updateResult = await authService.sendsimplesmsverification(phonenumber);

      if (updateResult.statusCode == 200 || updateResult.statusCode == 201) {

        AppSnackbar.showSuccess("Success", "OTP send successfully");
        return true;
      } else {
        log("Failed to send OTP with status code: ${updateResult.statusCode}");
        return false;
      }
    } catch (e, stackTrace) {
      log("Provider send otp caught error: $e");
      log("Error stack trace: $stackTrace");
      AppSnackbar.showError("Error", "OTP send unsuccessfully");
      return false;
    } finally {

     }
  }
Future<bool> verifyphonenumber(String phonenumber,String otp) async {

     if (!await Connection.checkConnection()) {
      log("No Internet Connection");
      _updateLoaderStatus(false);
      return false;
    }

    try {
      final updateResult = await authService.verifyphonenumber(phonenumber,otp);

      if (updateResult.statusCode == 200 || updateResult.statusCode == 201) {

        AppSnackbar.showSuccess("Success", "OTP Validate successfully");
        return true;
      } else {
        log("Failed to validate OTP with status code: ${updateResult.statusCode}");
        return false;
      }
    } catch (e, stackTrace) {
      log("Provider validate otp caught error: $e");
      log("Error stack trace: $stackTrace");
      AppSnackbar.showError("Error", "OTP Validate unsuccessfully");
      return false;
    } finally {

     }
  }

  Future<bool> login(String email, String password) async {
    // Check for internet connection before proceeding
    if (!(await Connection.checkConnection())) {
      AppSnackbar.showError("Error", "No Internet Connection");
      log("No Internet Connection");
      _updateLoaderStatus(false);
      return false;
    }

    _updateLoaderStatus(true);

    try {
      // Attempt user sign in through the service
      final authResult = await authService.signIn(
        email.trim(),
        password.trim(),
        deviceId,
        deviceModel,
        ipAddress,
      );

      // Handle successful login
      if ((authResult.statusCode == 200 || authResult.statusCode == 201) &&
          authResult.data != null) {
        await _handleSuccessfulLogin(authResult, email, password);
        _updateLoaderStatus(false);
        return true;
      }

      // Handle different types of errors
      switch (authResult.statusCode) {
        case 401:
          AppSnackbar.showError("Error", "Wrong credentials.");
          break;
        case 400:
          _handleLoginErrors(authResult.errorMessage);
          break;
        default:
          AppSnackbar.showError("Error", "Sign in Error");
      }

      _updateLoaderStatus(false);
      return false;
    } catch (e, stackTrace) {
      // Generic catch for unexpected errors
      AppSnackbar.showError("Error", "Server Error. Please try again later.");
      log("Login provider caught error: $e");
      log("Login provider error stack trace: $stackTrace");
      _updateLoaderStatus(false);
      return false;
    }
  }

  // Helper to update the loader state and notify listeners
  void _updateLoaderStatus(bool status) {
    loader = status;
    notifyListeners();
  }

  // Helper to handle successful login process and SharedPreferences updates
  Future<void> _handleSuccessfulLogin(APIResponse<LoginResponse> authResult,
      String email, String password) async {
    await fetchProfile();

    // Batch update SharedPreferences
    await Future.wait([
      _prefs.setString('Email', email),
      _prefs.setString('Password', password),
      _prefs.setBool("isLoggedIn", true),
      _prefs.setString("Role", authResult.data!.roles!),
    ]);
  }

  // Helper to handle error messages during login
  void _handleLoginErrors(String? errorMessage) {
    final translatedTitle = languageSingleton.translate("Sign in Error");
    String translatedMessage;

    switch (errorMessage?.trim()) {
      case "Wrong userName":
        translatedMessage = "Oops, this account does not exist in our records";
        break;
      case "Wrong Password":
        translatedMessage = "Oops, Wrong password";
        break;
      default:
        translatedMessage = "Wrong credentials.";
    }

    AppSnackbar.showError("Error", translatedMessage);
  }

  // Helper to display snack bar messages
  Future<String> getIpAddress() async {
    try {
      final response =
          await http.get(Uri.parse('https://api.ipify.org?format=json'));
      if (response.statusCode == 200) {
        final jsonResponse = json.decode(response.body);
        ipAddress = jsonResponse['ip'];
        return jsonResponse['ip']; // IP Address
      }
    } catch (e) {
      print('Failed to get IP address: $e');
    }
    return '';
  }

  Future<Map<String, String>> getDeviceInfo() async {
    DeviceInfoPlugin deviceInfo = DeviceInfoPlugin();

    if (Platform.isAndroid) {
      AndroidDeviceInfo androidInfo = await deviceInfo.androidInfo;
      deviceId = androidInfo.id ?? ""; // Device ID
      deviceType = "Android"; // Device Type
    } else if (Platform.isIOS) {
      IosDeviceInfo iosInfo = await deviceInfo.iosInfo;
      deviceId = iosInfo.identifierForVendor ?? ""; // Device ID
      deviceType = "iOS"; // Device Type
    }

    return {
      'deviceId': deviceId,
      'deviceType': deviceType,
    };
  }

  Future<String> getDeviceToken() async {
    FirebaseMessaging messaging = FirebaseMessaging.instance;
    String? token = await messaging.getToken();
    dToken = token ?? "";
    return token ?? "";
  }

  Future<void> _initializeDeviceSpecificSettings() async {
    final deviceInfo = DeviceInfoPlugin();
    if (Platform.isAndroid) {
      final androidInfo = await deviceInfo.androidInfo;
      utils.setApiLevel(androidInfo.version.sdkInt,androidInfo.brand.toLowerCase());

      // Request to disable battery optimization
      // await _requestBatteryOptimizationException();
    }
  }

  Future<bool> fetchProfile() async {
    if (!await Connection.checkConnection()) {
      log("No Internet Connection");
      _updateLoaderStatus(false);
      return false;
    }
    _initializeDeviceSpecificSettings();
    _updateLoaderStatus(true);
    try {
      final fetchProfileResult = await authService.getCurrentUser();

      // Check for successful response
      if (fetchProfileResult.statusCode == 200 ||fetchProfileResult.statusCode == 201) {
        if (fetchProfileResult.data == null) {
          log("No data found in the response");
          return false;
        }

        profile = fetchProfileResult.data;
        print("+++++++++++++++++++++++++++++++++ ${profile?.role}");
        // Check role validity
        if (profile?.role == null || profile?.role != "ROLE_USER") {
          log("This is not a driver --------------------------------");
          return false;
        }
        print("+++++++++++++++++++++++++++++++++ 01");
        utils.updateCurrentUser(profile!);
        print("+++++++++++++++++++++++++++++++++ 02");
        await utils.getToken();
        log("Profile loaded successfully: Email: ${utils.user?.email}, User ID: ${utils.user?.id}");
        return true;
      } else {
        log("Failed to load profile with status code: ${fetchProfileResult.statusCode}");
        return false;
      }
    } catch (e, stackTrace) {
      log("Provider fetchProfile caught error: $e");
      log("Error stack trace: $stackTrace");
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }

  // New method to update the profile picture
  Future<void> updateProfilePicture(File image) async {
    if (!await Connection.checkConnection()) {
      log("No Internet Connection");
      return;
    }

    _updateLoaderStatus(true);
    try {
      final response =
          await authService.updateProfilePicture(image, utils.user!.id!);

      if (response.statusCode == 200 || response.statusCode == 201) {
        log("Profile picture updated successfully");
        final updatedUser = users.fromJson(response.data);
        utils.updateCurrentUser(updatedUser);
      } else {
        AppSnackbar.showError("Error", "Failed to update profile picture");
      }
      _updateLoaderStatus(false);
    } catch (e, stackTrace) {
      log("Error updating profile picture: $e");
      log("Error stack trace: $stackTrace");
      AppSnackbar.showError(
          "Error", "An error occurred while updating the profile picture");
    } finally {
      _updateLoaderStatus(false);
    }
  }

  Future<bool> phoneSignUp(String phoneNumber) async {
    log("phoneNumber: $phoneNumber");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);
    try {
      final devicetoken = await getDeviceToken();
      final sendCodeResult =  await authService.phoneSignUP(phoneNumber, devicetoken);
      log("Status Code: ${sendCodeResult.statusCode}");
      log("data: ${sendCodeResult.data}");
      log("error Message: ${sendCodeResult.errorMessage}");

      if (sendCodeResult.statusCode == 200 || sendCodeResult.statusCode == 201) {
        return true;
      } else {
        AppSnackbar.showError("Error", "Error happen with OTP please try again later");
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Error happen with OTP please try again later');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }
  Future<bool> phoneSignUPOtpWhatsapp(String phoneNumber) async {
    log("phoneNumber: $phoneNumber");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);
    try {
      final devicetoken = await getDeviceToken();
      final sendCodeResult =  await authService.phoneSignUPOtpWhatsapp(phoneNumber, devicetoken);
      log("Status Code: ${sendCodeResult.statusCode}");
      log("data: ${sendCodeResult.data}");
      log("error Message: ${sendCodeResult.errorMessage}");

      if (sendCodeResult.statusCode == 200 || sendCodeResult.statusCode == 201) {
        return true;
      } else {
        AppSnackbar.showError("Error", 'Error happen with OTP please try again later');
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Error happen with OTP please try again later');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }
  Future<bool> phoneForgetPassword(String phoneNumber) async {
    log("phoneNumber: $phoneNumber");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);

    try {
      final sendCodeResult =  await authService.phoneForgetPassword(phoneNumber);
      log("Status Code: ${sendCodeResult.statusCode}");
      log("data: ${sendCodeResult.data}");
      log("error Message: ${sendCodeResult.errorMessage}");
      if (sendCodeResult.statusCode == 200 ||
          sendCodeResult.statusCode == 201) {
        return true;
      } else {
        AppSnackbar.showError("Error",'Error happen when trying to reset password with OTP please try again later');
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Error happen when trying to reset password with OTP please try again later');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }
  Future<bool> phoneForgetPasswordSendWithWhatsapp(String phoneNumber) async {
    log("phoneNumber: $phoneNumber");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);

    try {
      final sendCodeResult =  await authService.phoneForgetPasswordWhatsapp(phoneNumber);
      log("Status Code: ${sendCodeResult.statusCode}");
      log("data: ${sendCodeResult.data}");
      log("error Message: ${sendCodeResult.errorMessage}");
      if (sendCodeResult.statusCode == 200 ||
          sendCodeResult.statusCode == 201) {
        return true;
      } else {
        AppSnackbar.showError("Error",'Error happen when trying to reset password with whatsapp please try again later');
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Error happen when trying to reset password with whatsapp please try again later');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }

  Future<bool> isPhoneNumberExist(String phoneNumber) async {
    log("phoneNumber: $phoneNumber");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);

    try {
      final sendCodeResult = await authService.isPhoneNumberExist(phoneNumber);
      log("isPhoneNumberExist --- Status Code: ${sendCodeResult.statusCode}");
      log("isPhoneNumberExist --- data: ${sendCodeResult.data}");
      log("isPhoneNumberExist --- error Message: ${sendCodeResult.errorMessage}");

      if (sendCodeResult.isValidResponse) {
        return sendCodeResult.data ?? false;
      } else {
        AppSnackbar.showError("Error", 'input error please try a valid phone-number character');
        return false; // safer to return false here, not true
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'input error please try a valid phone-number character');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }

  Future<bool> ChangePassword(String password) async {
    log("password: $password");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);

    try {
      final sendCodeResult = await authService.ChangePassword(password);
      log("Status Code: ${sendCodeResult.statusCode}");
      log("data: ${sendCodeResult.data}");
      log("error Message: ${sendCodeResult.errorMessage}");

      if (sendCodeResult.statusCode == 200 || sendCodeResult.statusCode == 201) {
        final responseBody = sendCodeResult.data;

        if (responseBody != null && responseBody.isNotEmpty) {
          // The response body IS the token. No JSON parsing is needed.
          final String token = responseBody;
          log("Token: $token");

          Get.offAll(() => const AllowLocationScreen(showRegistration: true,));

        }

        // For a normal user, return true to proceed to the next step (e.g., OTP screen).
        return true;
      } else {
        AppSnackbar.showError("Error",
            'Password update unsuccessfully , please check you typo'); // ${sendCodeResult.errorMessage}');
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Unexpected error occurred');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }
  Future<bool> ResetPassword(String newPassword,String phonenumber,String code) async {
    log("password: $newPassword");
    log("phonenumber: $phonenumber");
    log("code: $code");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);

    try {
      final sendCodeResult = await authService.resetPassword(newPassword,phonenumber,code);
      log("Status Code: ${sendCodeResult.statusCode}");
      log("data: ${sendCodeResult.data}");
      log("error Message: ${sendCodeResult.errorMessage}");

      if (sendCodeResult.statusCode == 200 ||
          sendCodeResult.statusCode == 201) {
        final responseBody = sendCodeResult.data;

        if (responseBody != null && responseBody.isNotEmpty) {
          final String token = responseBody;
          log("Token: $token");
          Get.offAll(() => const LoginScreen());
        }
        return true;
      } else {
        AppSnackbar.showError("Error",
            'Unexpected error occurred');
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Unexpected error occurred');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }

  Future<bool> phoneLogin(String phoneNumber, String password) async {
    log("phoneNumber: $phoneNumber");
    log("password: $password");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);

    try {
      final devicetoken = await getDeviceToken();
      final sendCodeResult =
          await authService.phoneLogin(phoneNumber, devicetoken, password);
      log("Status Code: ${sendCodeResult.statusCode}");
      log("data: ${sendCodeResult.data}");
      log("error Message: ${sendCodeResult.errorMessage}");

      if (sendCodeResult.statusCode == 200 ||
          sendCodeResult.statusCode == 201) {
        final responseBody = sendCodeResult.data;

        if (responseBody != null && responseBody.isNotEmpty) {
          // The response body IS the token. No JSON parsing is needed.
          final String token = responseBody;
          log("Token: $token");

          // Your existing logic for the special test number
          if (phoneNumber.contains("99991111")) {
            var prefs = await SharedPreferences.getInstance();
            await prefs.setString('token', token);
            Get.offAll(() => const AllowLocationScreen(showRegistration: false));
            return false; // Return false as per original logic after navigation
          }
        }

        // For a normal user, return true to proceed to the next step (e.g., OTP screen).
        return true;
      } else {
        AppSnackbar.showError("Error",sendCodeResult.errorMessage??"Please check your phone number or password");
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError('Error', 'Unexpected error occurred');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }

  Future<bool> validateOTP(
      String phoneNum, String code, BuildContext context) async {
    if (!await Connection.checkConnection()) {
      log("-----> No Internet Connection");
      _updateLoaderStatus(false);
      return false;
    }

    _updateLoaderStatus(true);
    try {
      await Future.wait([
        getDeviceToken(),
        getDeviceInfo(),
        getIpAddress(),
      ]);

      final verifyResult = await authService.verifyCode(
          phoneNum, code, deviceId, deviceType, ipAddress, dToken);

      if (verifyResult.statusCode == 200 || verifyResult.statusCode == 201) {
        _updateLoaderStatus(false);
        onValidate?.call();
        onValidate = null;
        return true;
      } else {
        AppSnackbar.showError("Error", verifyResult.errorMessage!);
        _updateLoaderStatus(false);
        return false;
      }
    } catch (e, stackTrace) {
      _updateLoaderStatus(false);
      log("-----> Verify OTP Caught Error: $e");
      log("-----> Verify OTP Caught Error StackTrace: $stackTrace");
      return false;
    }
  }
  Future<bool> validateOTPAuth(
      String phoneNum, String code, BuildContext context) async {
    if (!await Connection.checkConnection()) {
      log("-----> No Internet Connection");
      _updateLoaderStatus(false);
      return false;
    }

    _updateLoaderStatus(true);
    try {
      await Future.wait([
        getDeviceToken(),
        getDeviceInfo(),
        getIpAddress(),
      ]);

      final verifyResult = await authService.verifyCodeauth(
          phoneNum, code, deviceId, deviceType, ipAddress, dToken);

      if (verifyResult.statusCode == 200 || verifyResult.statusCode == 201) {
        _updateLoaderStatus(false);
        onValidate?.call();
        onValidate = null;
        return true;
      } else {
        AppSnackbar.showError("Error", verifyResult.errorMessage!);
        _updateLoaderStatus(false);
        return false;
      }
    } catch (e, stackTrace) {
      _updateLoaderStatus(false);
      log("-----> Verify OTP Caught Error: $e");
      log("-----> Verify OTP Caught Error StackTrace: $stackTrace");
      return false;
    }
  }
  Future<bool> validateResetPasswordOTP(
      String phoneNum, String code, BuildContext context) async {

    final languageProvider = Provider.of<LanguageProvider>(context, listen: false);

    // Convert enum to string for translation
    String langCode;
    switch (languageProvider.currentLangCode) {
      case Language.en:
        langCode = 'en';
        break;
      case Language.fr:
        langCode = 'fr';
        break;
      case Language.ar:
        langCode = 'ar';
        break;
      default:
        langCode = 'en';
    }

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      _updateLoaderStatus(false);
      return false;
    }

    _updateLoaderStatus(true);

    try {
      await Future.wait([
        getDeviceToken(),
        getDeviceInfo(),
        getIpAddress(),
      ]);

      final verifyResult = await authService.validateResetPasswordOTP(phoneNum, code);

      _updateLoaderStatus(false);

      final statusCode = verifyResult.statusCode ?? 500;
      final backendData = verifyResult.data;
      log('================+++>>>> $statusCode');
      log('================+++>>>> ${verifyResult.data}');

      String message;

      // Handle 200/201 = success
      if (statusCode == 200 || statusCode == 201) {
        message = OTPMessages.get("", langCode); // null = "code correct"
        AppSnackbar.showSuccess("Success", message);
        return true;
      }

      // Handle error codes like 406
      if (statusCode == 406) {
        // backendData could be "expired", "invalidToken", or other string
        message = OTPMessages.get(backendData??"", langCode);
        AppSnackbar.showError("Error", message);
        return false;
      }

      // Other unexpected errors
      message = OTPMessages.get(backendData ?? 'this code is wrong', langCode);
      AppSnackbar.showError("Error", message);
      return false;

    } catch (e, stackTrace) {
      _updateLoaderStatus(false);
      log("-----> Verify OTP Caught Error: $e");
      log("-----> Verify OTP Caught Error StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Unexpected error occurred');
      return false;
    }
  }


  Future<void> logOut() async {
    try {
      _logoutloading = true;
      notifyListeners();
      var res = await authService.logOut();
      if (res.statusCode == 200 || res.statusCode == 201) {
        utils.clearProviderData();

        await utils.logout();
        Get.offAll(() => const LoginScreen());
      } else {
        print("*-*-*-*-*- ${res.statusCode} +++${res.data}");
      }
    } catch (e, st) {
      log("e : ${e.toString()}");
      log("st : ${st.toString()}");
    } finally {
      _logoutloading = false;
      notifyListeners();
    }
  }

  Future<void> deleteUser() async {
    try {
      _logoutloading = true;
      notifyListeners();
      var res = await authService.deleteUser();
      if (res.statusCode == 200 || res.statusCode == 201) {
        utils.clearProviderData();
        await utils.logout();
        Get.offAll(() => const LoginScreen());
      } else {
        print("*-*-*-*-*- ${res.statusCode} +++${res.data}");
      }
    } catch (e, st) {
      log("e : ${e.toString()}");
      log("st : ${st.toString()}");
    } finally {
      _logoutloading = false;
      notifyListeners();
    }
  }

  Future<bool> phoneTextLogin(String phoneNumber) async {
    log("phoneNumber: $phoneNumber");

    if (!await Connection.checkConnection()) {
      AppSnackbar.showError("Error", 'No Internet Connection');
      log("-----> No Internet Connection");
      return false;
    }

    _updateLoaderStatus(true);

    try {
      final devicetoken = await getDeviceToken();
      final sendCodeResult = await authService.phoneTextLogin(phoneNumber, devicetoken);
      log("devicetoken:---- $devicetoken , Status Code: ${sendCodeResult.statusCode} , data: ${sendCodeResult.data} ,  error Message: ${sendCodeResult.errorMessage}");

      if (sendCodeResult.statusCode == 200 || sendCodeResult.statusCode == 201) {
        if (sendCodeResult.data != null && sendCodeResult.data is Map<String, dynamic>) {
          final dataMap = sendCodeResult.data as Map<String, dynamic>;

          // Check if token is present (bypass for test number)
          if (dataMap.containsKey('token')) {
            final String token = dataMap['token'];
            log("Token ***--*-*-*: $token");

            if (phoneNumber.contains("99991111")) {
              var prefs = await SharedPreferences.getInstance();
              await prefs.setString('token', token);
            }
            return true;
          }

          // No token means OTP was sent successfully (any other response)
          log("OTP sent successfully: ${dataMap['status'] ?? 'pending verification'}");
          return true;
        }

        // Success
        return true;
      } else {
        AppSnackbar.showError("Error", sendCodeResult.errorMessage ?? "Please check your phone number or password");
        return false;
      }
    } catch (e, stackTrace) {
      log("Error: $e");
      log("StackTrace: $stackTrace");
      AppSnackbar.showError("Error", 'Unexpected error occurred');
      return false;
    } finally {
      _updateLoaderStatus(false);
    }
  }

  socialLoginHandling(
      BuildContext context,
      String token,
      ) async {
    log(token);
    try {
      final prefs = await SharedPreferences.getInstance();
      prefs.setString('token', token.toString());
      // print("I was here 33333");
      await prefs.setBool("isLoggedIn", true);
      if (await Connection.checkConnection()) {
        loader = true;
        notifyListeners();
        //loading
        log("connection step done");

        if (await context.read<UtilsProvider>().initPlatformState() && await context.read<UtilsProvider>().getIpAddress()) {
          final authresult = await authService.socialLoginMissingData(Platform.isIOS ? context.read<UtilsProvider>().deviceInfo['identifierForVendor'] : context.read<UtilsProvider>().deviceInfo['androidId'] ?? context.read<UtilsProvider>().deviceInfo['id'], "user", context.read<UtilsProvider>().ipAddress);
          log(authresult.statusCode.toString());
          log(authresult.data.toString());

          if ((authresult.statusCode == 200 || authresult.statusCode == 201) && authresult.data != null && authresult.data!.user != null) {

            loader = false;
            notifyListeners();
          } else {
            log(authresult.statusCode.toString());
            //stop loading
            if (authresult.statusCode == 409) {
              loader = false;
              notifyListeners();
            }
            if (authresult.statusCode == 400 ||
                authresult.statusCode == 402 ||
                authresult.statusCode == 403) {
              loader = false;
              notifyListeners();
            }
            if (authresult.statusCode == 401) {
              loader = false;
              notifyListeners();
            }
            if (authresult.statusCode! >= 500) {
              loader = false;
              notifyListeners();
            }
          }
        } else {
          loader = false;
          notifyListeners();
        }
      } else {
        loader = false;
        notifyListeners();
      }
    } catch (e) {
      log(e.toString());
    }
  }

  loginApple(String token, BuildContext context, bool isSingUp) async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setString("token", token);
    await prefs.setBool("isLoggedIn", true);
    await prefs.setString('refreshToken', "INVALID");
    await addMissingDataApple(context, token);


  }
  addMissingDataApple(BuildContext context, String token) async {
    log(token);
    try {
      final prefs = await SharedPreferences.getInstance();
      prefs.setString('token', token.toString());
      // print("I was here 33333");
      await prefs.setBool("isLoggedIn", true);
      final initPlatformState =
      await context.read<UtilsProvider>().initPlatformState();
      log(context.read<UtilsProvider>().deviceInfo.toString());
      final ipAddressFetched =
      await context.read<UtilsProvider>().getIpAddress();
      if (await Connection.checkConnection()) {
        loader = true;
        notifyListeners();
        //loading
        log("connection step done");

        if (initPlatformState && ipAddressFetched) {
          final authresult = await authService.socialLoginMissingData(
              context.read<UtilsProvider>().deviceInfo['identifierForVendor'] ??
                  context.read<UtilsProvider>().deviceInfo['id'],
              "phone",
              context.read<UtilsProvider>().ipAddress);
          log(authresult.statusCode.toString());
          log(authresult.data.toString());

          if ((authresult.statusCode == 200 || authresult.statusCode == 201)) {
            await fetchProfile();
            await prefs.setBool("isLoggedIn", true);
            AppSnackbar.showSuccess("Success", "User Signed In Successfully");
            // Get.toNamed();
            // Get.back(id: ProfileNavigation.id);
            loader = false;
            notifyListeners();
          } else {
            log(authresult.statusCode.toString());
            //stop loading
            if (authresult.statusCode == 409) {
              loader = false;
              notifyListeners();
              AppSnackbar.showError("Error", "Sign in error");

            }

            if (authresult.statusCode == 400 ||
                authresult.statusCode == 402 ||
                authresult.statusCode == 403) {
              loader = false;
              notifyListeners();
            }
            if (authresult.statusCode == 401) {
              loader = false;
              notifyListeners();
            }
            if (authresult.statusCode! >= 500) {
              loader = false;
              notifyListeners();
            }
          }
        } else {
          loader = false;
          notifyListeners();
        }
      } else {
        loader = false;
        notifyListeners();
      }
    } catch (e) {
      log(e.toString());
    }
  }



  Future<bool> addReferral(String code) async {
    try {
      loader = true;
      notifyListeners();
      var res = await authService.addReferral(code);
      if (res.statusCode == 200 || res.statusCode == 201) {
        AppSnackbar.showSuccess("Success", "Your referral add successfully");
        return true;
      } else {
        AppSnackbar.showError("Error", res.errorMessage?? "Please check your code" );
      return false;
      }
    } catch (e, st) {
      AppSnackbar.showError("Error", "Please check your code" );
      log("e : ${e.toString()}");
      log("st : ${st.toString()}");
      return false;
    } finally {
      loader = false;
      notifyListeners();
    }
  }
}