ApiProvider

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

import 'package:base_architecture/data_layer/api/dio_interceptor.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/add_to_library_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/categories_selections.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/change_password_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/main_categories_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/put_mark_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/recover_password_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/search_query_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/social_login_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/update_password_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/arab_settings_model.dart';
import 'package:base_architecture/data_layer/models/api_models/book_details_model.dart';
import 'package:base_architecture/data_layer/models/api_models/categories_model.dart';
import 'package:base_architecture/data_layer/models/api_models/contributors.dart';
import 'package:base_architecture/data_layer/models/api_models/favourite_categories_model.dart';
import 'package:base_architecture/data_layer/models/api_models/home_main_categories_model.dart';
import 'package:base_architecture/data_layer/models/api_models/home_strips_model.dart';
import 'package:base_architecture/data_layer/models/api_models/is_following_model.dart';
import 'package:base_architecture/data_layer/models/api_models/search_result_model.dart';
import 'package:base_architecture/data_layer/models/api_models/see_more_model.dart';
import 'package:base_architecture/data_layer/models/banner_model.dart';
import 'package:base_architecture/data_layer/models/comments_model.dart';
import 'package:base_architecture/presentation/notifiers/auth_notifier/auth_notifier.dart';
import 'package:base_architecture/presentation/notifiers/bottom_nav_bar_notifier.dart/bottom_nav_bar_notifier.dart';
import 'package:base_architecture/presentation/notifiers/contact_us_notifier/contact_us_notifier.dart';
import 'package:base_architecture/presentation/pages/terms_page/pop_up_terms_page/pop_up_terms_page.dart';
import 'package:dio/dio.dart' as m_part;
import 'package:dio/dio.dart';
import 'package:easy_localization/easy_localization.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:rx_shared_preferences/rx_shared_preferences.dart';

import 'package:base_architecture/core/enums/dialog_path_enum.dart';
import 'package:base_architecture/core/shared_widgets/custom_dialog.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/login_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/register_dto.dart';
import 'package:base_architecture/data_layer/models/api_models/Dto/verify_otp_dto.dart';
import 'package:base_architecture/data_layer/models/app_user_model/app_user_model.dart';
import 'package:base_architecture/data_layer/models/api_models/countries_list.dart';
import 'package:base_architecture/presentation/pages/bottom_navigation_bar/bottom_nav_bar.dart';
import 'package:base_architecture/presentation/pages/main/main_page.dart';
import 'package:base_architecture/presentation/pages/phone_verification_page/phone_verification_page.dart';
import 'package:base_architecture/presentation/pages/phone_verification_page/widgets/success_dialog.dart';
import 'package:base_architecture/presentation/props/phone_verification_props.dart';

class ApiProvider {
  ApiProvider({required this.httpClient}) {
    httpClient.interceptors.add(DioInterceptors(httpClient));
  }

  String baseUrl = 'https://arabcast.nqa.nadsoft.co/api/v1/';

  final Dio httpClient;

  Future registerUser(RegisterationDto param, List<File> posts) async {
    m_part.FormData form = m_part.FormData.fromMap({
      'first_name': param.firstName,
      'last_name': param.lastName,
      'gender': param.gender,
      'dob': param.dob,
      'mobile': param.mobile,
      'email': param.email,
      'password': param.password,
      'confirm_password': param.confirmPassword,
      'country_id': param.countryId,
      'disable[]': param.disable,
      'iso_code': param.isoCode,
      'phone_code': param.phoneCode,
      'condition_accepted': param.conditionAccepted,
    });
    for (final File post in posts) {
      form.files.add(
        MapEntry(
          'files[]',
          m_part.MultipartFile.fromBytes(
            post.readAsBytesSync(),
            filename: post.path.split('/').last,
          ),
        ),
      );
    }
    try {
      await httpClient
          .post(
        baseUrl + 'register',
        data: form,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'multipart/form-data',
          },
        ),
      )
          .then(
        (m_part.Response value) async {
          if (value.statusCode == 200) {
            await showDialog(
              context: navigatorKey.currentContext!,
              builder: (BuildContext context) {
                Future.delayed(
                  const Duration(
                    seconds: 5,
                  ),
                  () {
                    Navigator.of(context).pop();
                    Navigator.push(
                      context,
                      MaterialPageRoute(
                        builder: (BuildContext context) =>
                            PhoneVerificationPage(
                          props: PhoneVerificationProps(
                            phoneNumber: param.mobile!,
                            pathEnum: DialogPathEnum.introPage,
                          ),
                        ),
                      ),
                    );
                  },
                );

                return CustomDialog(
                  assetPath: 'assets/svg/icSentImage.svg',
                  header:
                      'We have sent a message to your phone to complete the registration',
                  body: value.data['custom_message'],
                  hasButton: false,
                );
              },
            );
          }
          return value;
        },
      );
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'].toString()),
          backgroundColor: Colors.red,
        ),
      );
    }
  }

  Future<int?> checkUserSocial(SocialLoginDto param) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    int? statusCode;
    m_part.FormData form = m_part.FormData.fromMap({
      'provider': param.provider,
      'provider_id': param.providerId,
      'access_provider_token': param.accessProviderToken,
      'email': param.email,
    });
    log(param.toJson().toString());
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'social/login',
        data: form,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'multipart/form-data',
          },
        ),
      );

      if (response.statusCode == 200) {
        await rxPrefs.setString(
          'token',
          response.data['token_data']['token'],
        );
        // await rxPrefs.setString(
        //   'refresh_token',
        //   response.data['token_data']['refresh_token'],
        // );
        // await rxPrefs.setString(
        //   'server_time',
        //   response.data['token_data']['server_time'],
        // );
        await getUserDataByToken(
          response.data['token_data']['token'],
        );
      }
      statusCode = response.statusCode;
      return statusCode;
    } on DioError catch (e) {
      // log(e.error);
      statusCode = e.response!.statusCode;
      return statusCode;
    }
  }

  Future sociaLogin(SocialLoginDto param, List<File> posts) async {
    m_part.FormData form = m_part.FormData.fromMap({
      'provider': param.provider,
      'provider_id': param.providerId,
      'access_provider_token': param.accessProviderToken,
      'first_name': param.firstName,
      'last_name': param.lastName,
      'gender': param.gender,
      'dob': param.dob,
      'mobile': param.mobile,
      'email': param.email,
      'country_id': param.countryId,
      'disable[]': param.disable,
      'iso_code': param.isoCode,
      'phone_code': param.phoneCode,
      'condition_accepted': param.conditionAccepted,
    });
    for (final File post in posts) {
      form.files.add(
        MapEntry(
          'files[]',
          m_part.MultipartFile.fromBytes(
            post.readAsBytesSync(),
            filename: post.path.split('/').last,
          ),
        ),
      );
    }
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'social/login',
        data: form,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'multipart/form-data',
          },
        ),
      );
      if (response.statusCode == 200) {
        await showDialog(
          context: navigatorKey.currentContext!,
          builder: (BuildContext context) {
            Future.delayed(
              const Duration(
                seconds: 5,
              ),
              () {
                Navigator.of(context).pop();
                Navigator.push(
                  context,
                  MaterialPageRoute(
                    builder: (BuildContext context) => PhoneVerificationPage(
                      props: PhoneVerificationProps(
                        phoneNumber: param.mobile!,
                        pathEnum: DialogPathEnum.introPage,
                      ),
                    ),
                  ),
                );
              },
            );

            return CustomDialog(
              assetPath: 'assets/svg/icSentImage.svg',
              header:
                  'We have sent a message to your phone to complete the registration',
              body: response.data['custom_message'],
              hasButton: false,
            );
          },
        );
      } else if (response.statusCode == 412) {}
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
  }

  Future verifyUser(VerifyOtpDto param, List<File> posts) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final AppUser appUser = AppUser();
    m_part.FormData form = m_part.FormData.fromMap(
      {
        'provider': param.provider,
        'provider_id': param.providerId,
        'first_name': param.firstName,
        'last_name': param.lastName,
        'gender': param.gender,
        'dob': param.dob,
        'mobile': param.mobile,
        'email': param.email,
        'password': param.password,
        'confirm_password': param.confirmPassword,
        'country_id': param.countryId,
        'iso_code': param.isoCode,
        'disable[]': param.disable,
        'phone_code': param.phoneCode,
        'condition_accepted': param.conditionAccepted,
        'code': param.code,
      },
    );
    for (final File post in posts) {
      form.files.add(
        MapEntry(
          'files[]',
          m_part.MultipartFile.fromBytes(
            post.readAsBytesSync(),
            filename: post.path.split('/').last,
          ),
        ),
      );
    }
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'verify-mobile',
        data: form,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'multipart/form-data',
          },
        ),
      );

      if (response.statusCode == 200) {
        await rxPrefs.setString(
          'token',
          response.data['token_data']['token'],
        );
        await getUserDataByToken(
          response.data['token_data']['token'],
          path: DialogPathEnum.introPage,
        );
        return appUser;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      return e;
    }
  }

  Future verifySocialUser(VerifyOtpDto param, List<File> posts) async {
    final AppUser appUser = AppUser();
    m_part.FormData form = m_part.FormData.fromMap(
      {
        'provider': param.provider,
        'provider_id': param.providerId,
        'access_provider_token': param.accessProviderToken,
        'first_name': param.firstName,
        'last_name': param.lastName,
        'gender': param.gender,
        'dob': param.dob,
        'mobile': param.mobile,
        'email': param.email,
        'country_id': param.countryId,
        'iso_code': param.isoCode,
        'disable[]': param.disable,
        'phone_code': param.phoneCode,
        'code': param.code,
      },
    );
    for (final File post in posts) {
      form.files.add(
        MapEntry(
          'files[]',
          m_part.MultipartFile.fromBytes(
            post.readAsBytesSync(),
            filename: post.path.split('/').last,
          ),
        ),
      );
    }
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'verify-mobile',
        data: form,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'multipart/form-data',
          },
        ),
      );

      if (response.statusCode == 200) {
        return appUser;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      return e;
    }
  }

  providerLogin(AppUserDto param) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final AppUser appUser = AppUser();
    BottomNavBarNotifier barNotifier = Provider.of<BottomNavBarNotifier>(
      navigatorKey.currentContext!,
      listen: false,
    );
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'login',
        data: param.toJson(),
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      );
      if (response.statusCode == 200) {
        await rxPrefs.setString(
          'token',
          response.data['token_data']['token'],
        );
        await getUserDataByToken(
          response.data['token_data']['token'],
        ).then((value) async {
          barNotifier.setSelectedIndexToHomeTab();
          await Navigator.pushReplacement(
            navigatorKey.currentContext!,
            MaterialPageRoute(
              builder: (BuildContext context) => const BottomNavBar(),
            ),
          );
        });
        return appUser;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      return appUser;
    }
  }

  // FOR LOGIN AND REGISTERATION
  Future getUserDataByToken(String token, {DialogPathEnum? path}) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final AuthNotifier authNotifier = Provider.of<AuthNotifier>(
      navigatorKey.currentContext!,
      listen: false,
    );
    AppUser appUser = AppUser();
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'users/user-account',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      );
      if (response.statusCode == 200) {
        await getArabSettings();
        appUser = AppUser.fromJson(response.data['data']);

        if (response.data['token_data']['last_condition_accepted'] == true) {
          authNotifier.setAppUser(appUser);

          await rxPrefs.setBool('onBoard', false);
          if (path == DialogPathEnum.introPage) {
            await showDialog(
              context: navigatorKey.currentContext!,
              builder: (BuildContext context) => const SuccessDialog(
                pathEnum: DialogPathEnum.introPage,
                title: 'Registration completed successfully',
                description:
                    'In the library, guests can listen, read books and listen to podcasts.',
              ),
            );
          } else {}
        } else {
          // pop view
          await Navigator.of(navigatorKey.currentContext!).push(
            MaterialPageRoute(
              fullscreenDialog: true,
              builder: (BuildContext context) =>
                  const PopUpTermsAndConditionsPage(),
            ),
          );
        }
      }
    } on DioError catch (e) {
      await AuthNotifier().resetAppUser();
      return appUser;
    }
    return appUser;
  }

  acceptTerms() async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'users/accept-conditions',
        options: Options(
          headers: {},
        ),
      );
      if (response.statusCode == 200) {
      } else {}
    } on DioError catch (e) {
      return e;
    }
  }

  // FOR UPDATING ACCOUNT
  getUserDataByTokenAccount(String token) async {
    final AuthNotifier authNotifier = Provider.of<AuthNotifier>(
      navigatorKey.currentContext!,
      listen: false,
    );
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    AppUser appUser = AppUser();
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'users/user-account',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      );
      if (response.statusCode == 200) {
        await rxPrefs.setString(
          'token',
          response.data['token_data']['token'],
        );
        appUser = AppUser.fromJson(response.data['data']);
        authNotifier.setAppUser(appUser);
      } else {}
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
    return appUser;
  }

  Future<int> recoverPassword(RecoverPasswordDto param) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'password-recovery',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
        data: param.toJson(),
      );
      if (response.statusCode == 200) {
        statusCode = response.statusCode!;
        return statusCode;
      }
    } on DioError catch (e) {
      statusCode = e.response!.statusCode!;
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      return statusCode;
    }
    return statusCode ?? 0;
  }

  Future<int> verifyPasswordOtp(RecoverPasswordDto param) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'password-verify',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
        data: param.toJson(),
      );
      if (response.statusCode == 200) {
        statusCode = response.statusCode!;
        return statusCode;
      }
    } on DioError catch (e) {
      statusCode = e.response!.statusCode!;
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      return statusCode;
    }
    return statusCode ?? 0;
  }

  Future<int> updatePassword(UpdatePasswordDto param) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'update-password',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
        data: param.toJson(),
      );
      if (response.statusCode == 200) {
        statusCode = response.statusCode!;
        return statusCode;
      }
    } on DioError catch (e) {
      statusCode = e.response!.statusCode!;
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      return statusCode;
    }
    return statusCode ?? 0;
  }

  Future<CountriesList?> getAllCountries() async {
    m_part.Response response = await httpClient.get(
      baseUrl + 'countries',
      options: Options(
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'lang': navigatorKey.currentContext!.locale.toString()
        },
      ),
    );
    if (response.statusCode == 200) {
      final Map<String, dynamic> validMap =
          json.decode(json.encode(response.data)) as Map<String, dynamic>;
      CountriesList resp = CountriesList.fromJson(validMap);
      return resp;
    }

    return null;
  }

  Future<FavouriteCategoriesModel> getAllFavCategories() async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    m_part.Response response = await httpClient.get(
      baseUrl + 'categories/main-categories',
      options: Options(
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
        },
      ),
    );
    if (response.statusCode == 200) {
      final validMap = json.decode(json.encode(response.data));

      FavouriteCategoriesModel resp =
          FavouriteCategoriesModel.fromJson(validMap);
      return resp;
    }

    return response.data;
  }

  postFavCategories(MainCategoriesDto param) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'categories/fav-categories',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
        data: param.toJson(),
      );
      if (response.statusCode == 200) {
        await Navigator.pushReplacement(
          navigatorKey.currentContext!,
          MaterialPageRoute(
            builder: (BuildContext context) => const BottomNavBar(),
          ),
        );
      }
    } on DioError catch (e) {
      return e;
    }
  }

  Future<int?> verifyEmail(String token) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'verify-email',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
      );
      if (response.statusCode == 200) {
        statusCode = response.statusCode;
        return statusCode;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
    return statusCode ?? 2;
  }

  Future<int?> verifyCompare(String token, VerifyOtpDto pincode) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'verify-compare',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
        data: pincode.toJson(),
      );
      if (response.statusCode == 200) {
        statusCode = response.statusCode;
        return statusCode;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
    return statusCode ?? 2;
  }

  Future<int?> changePassword(String token, ChangePasswordDto param) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'users/change-password',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
        data: param.toJson(),
      );
      if (response.statusCode == 200) {
        statusCode = response.statusCode;
        return statusCode;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
    return statusCode ?? 2;
  }

  Future<int?> updateMobile(String token, VerifyOtpDto param) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'users/update-mobile',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
        data: param.toJson(),
      );
      if (response.statusCode == 200) {
        statusCode = response.statusCode;
        return statusCode;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.statusCode.toString()),
          backgroundColor: Colors.red,
        ),
      );
    }
    return statusCode ?? 2;
  }

  Future<int?> verifyUpdatePhone(String token, VerifyOtpDto param) async {
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'users/verify-mobile',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
        data: param.toJson(),
      );
      if (response.statusCode == 200) {
        getUserDataByTokenAccount(token);
        statusCode = response.statusCode;
        ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
          SnackBar(
            content: Text(response.data['custom_message'] ?? 'NP'),
            backgroundColor: Colors.green,
          ),
        );
        return statusCode;
      }
    } on DioError catch (e) {
      print('object');
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text('NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
    return statusCode ?? 2;
  }

  Future<int?> updateAccount(
    String? token,
    RegisterationDto param,
    List<Map<String, dynamic>> posts,
    List<int> removed_ids,
  ) async {
    int? statusCode;
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    m_part.FormData form = m_part.FormData.fromMap({
      'first_name': param.firstName,
      'last_name': param.lastName,
      'dob': param.dob,
      'email': param.email,
      'country_id': param.countryId,
      'removed_files[]': removed_ids,
      'files[]': param.files,
    });
    log(jsonEncode(removed_ids));
    for (final Map<String, dynamic> post in posts) {
      form.files.add(
        MapEntry(
          'files[]',
          m_part.MultipartFile.fromBytes(
            post['file_path'].readAsBytesSync(),
            filename: post['file_path'].path.split('/').last,
          ),
        ),
      );
    }

    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'users/user-account',
        data: form,
        queryParameters: {},
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'multipart/form-data',
            'token': token,
          },
        ),
      );

      if (response.statusCode == 200) {
        statusCode = response.statusCode;
        await rxPrefs.setString(
          'token',
          response.data['token_data']['token'],
        );
        await getUserDataByTokenAccount(
          response.data['token_data']['token'],
        );
        return statusCode;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      print(e.response!);
    }
    return statusCode ?? 2;
  }

  Future<SearchResultModel> simpleSearch(SearchQueryDto query) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'books/filter',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'multipart/form-data',
            'token': token,
          },
        ),
        queryParameters: {
          'keyword': query.keyword,
          'sort': query.sort,
          'category_id': query.categoryId,
          'author_id': query.authorId,
          'reader_id': query.readerId,
          'publisher_id': query.publisherId,
          'translator_id': query.translatorId,
          'length_book': query.lengthBook,
          'publication_date': query.publicationDate,
          'format': query.format,
          'rate': query.rate,
          'type': query.type,
          'book_lang': query.bookLang
        },
      );
      if (response.statusCode == 200) {
        final Map<String, dynamic> validMap =
            json.decode(json.encode(response.data)) as Map<String, dynamic>;
        SearchResultModel resp = SearchResultModel.fromJson(validMap);
        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<HomeMainCategoriesModel> getHomeCategories(
    int limit,
    int offset,
  ) async {
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'categories/home',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {'limit': limit, 'offset': 0},
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        HomeMainCategoriesModel resp =
            HomeMainCategoriesModel.fromJson(validMap);
        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<SeeMoreModel> seeMoreRecentBooks() async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'books/last-added',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {'limit': 15, 'offset': 0},
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        SeeMoreModel resp = SeeMoreModel.fromJson(validMap);

        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<SeeMoreModel> seeMoreForYouBooks() async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'books/fav-books',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {'limit': 15, 'offset': 0},
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        SeeMoreModel resp = SeeMoreModel.fromJson(validMap);

        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<SeeMoreModel> seeMoreWritersBooks() async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'books/writers-chose',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {'limit': 15, 'offset': 0},
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        SeeMoreModel resp = SeeMoreModel.fromJson(validMap);

        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<SeeMoreModel> seeMoreMostReadBooks() async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'books/most-read',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {'limit': 15, 'offset': 0},
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        SeeMoreModel resp = SeeMoreModel.fromJson(validMap);

        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<CategoriesModel> getContributorInfo(
    CategoriesSelections selections,
    int pageIndex,
    int pageLimit,
  ) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'categories',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {
          'type': selections.type,
          'id': selections.id,
        },
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        CategoriesModel resp = CategoriesModel.fromJson(validMap);
        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      print('tttttttttttttt');
      log(e.response!.data.toString());
      return e.response!.data;
    }
  }

  Future<CategoriesModel> getAllCategories(
    CategoriesSelections selections,
    int pageIndex,
    int pageLimit,
  ) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      print(selections.toJson());
      print('===============OFFSET==============');
      m_part.Response response = await httpClient.get(
        baseUrl + 'categories',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {
          'type': selections.type,
          'keyword': selections.keyword,
          'id': selections.id,
          'sub_id': selections.sub_id,
          'sub_sub_id': selections.sub_sub_id,
          'limit': pageLimit,
          'offset': pageIndex,
        },
      );

      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        CategoriesModel resp = CategoriesModel.fromJson(validMap);

        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      print(e.response!.statusMessage);
      print('ssssssssssss');
      log(e.response!.data.toString());
      return e.response!.data;
    }
  }

  Future<IsFollowingModel> followContributor(
    int role_Id,
    int contributor_id,
    String type,
  ) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    int? statusCode;
    try {
      m_part.Response response = await httpClient.post(
        baseUrl + 'contributors/${contributor_id}/user-action',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
        queryParameters: {
          'role_id': role_Id,
          'type': type,
        },
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        IsFollowingModel resp = IsFollowingModel.fromJson(validMap);
        ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
          SnackBar(
            content: Text(response.data['custom_message'] ?? 'NP'),
            backgroundColor: Colors.green,
            duration: const Duration(milliseconds: 1000),
          ),
        );
        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );

      return e.response!.data;
    }
  }

  Future<IsFollowingModel> followCategory(int category_id) async {
    m_part.Response response;
    try {
      response = await httpClient.post(
        baseUrl + 'contributors/${category_id}/user-action',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
        queryParameters: {
          'role_id': 1,
          'type': 'category',
        },
      );
      if (response.statusCode == 200) {
        ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
          SnackBar(
            content: Text(response.data['custom_message'] ?? 'NP'),
            backgroundColor: Colors.green,
            duration: const Duration(milliseconds: 500),
          ),
        );
        return response.data;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
      return e.response!.data;
    }
    return response.data;
  }

  Future<ArabSettingsModel?> getArabSettings() async {
    ArabSettingsModel settings = ArabSettingsModel();
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? isoCode = await rxPrefs.getString('iso_code');
    final AuthNotifier authNotifier = Provider.of<AuthNotifier>(
      navigatorKey.currentContext!,
      listen: false,
    );
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'settings',
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
          },
        ),
      );

      if (response.statusCode == 200) {
        settings = ArabSettingsModel.fromJson(response.data);
        await rxPrefs.setString(
          'arabSettings',
          jsonEncode(settings),
        );
        await authNotifier.setArabSettings(settings);
        return settings;
      }
    } on DioError catch (e) {
      log(e.toString());

      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
    return null;
  }

  Future<BannerModel> getBannersList() async {
    BannerModel bannerModel = BannerModel();
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    final String? isoCode = await rxPrefs.getString('iso_code');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'banners',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      );

      if (response.statusCode == 200) {
        final banner = json.decode(json.encode(response.data));
        bannerModel = BannerModel.fromJson(banner);
        return bannerModel;
      } else {}

      return bannerModel;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future contactUs(List<File> posts) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    final ContactUsNotifier contactNotifier = Provider.of<ContactUsNotifier>(
      navigatorKey.currentContext!,
      listen: false,
    );

    bool tokenVar = token == null;

    m_part.FormData data = m_part.FormData.fromMap({
      'user_name': tokenVar ? contactNotifier.nameController!.text : null,
      'email': tokenVar ? contactNotifier.emailController!.text : null,
      'phone_code': tokenVar ? contactNotifier.phoneKey : null,
      'phone_number': tokenVar ? contactNotifier.phoneController!.text : null,
      'note': contactNotifier.notesController!.text,
      'contact_id': contactNotifier.selectedSubject.id ?? 1,
      'source': 'app',
    });

    for (final File image in posts) {
      data.files.add(
        MapEntry(
          'image',
          m_part.MultipartFile.fromBytes(
            image.readAsBytesSync(),
            filename: image.path.split('/').last,
          ),
        ),
      );
    }

    try {
      Future<m_part.Response> response = httpClient
          .post(
        baseUrl + 'contact-us',
        data: data,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      )
          .then((m_part.Response value) async {
        if (value.statusCode == 200) {
          contactNotifier.nameController!.clear();
          contactNotifier.emailController!.clear();
          contactNotifier.phoneController!.clear();
          contactNotifier.notesController!.clear();
          await showDialog(
            context: navigatorKey.currentContext!,
            builder: (BuildContext builder) => CustomDialog(
              assetPath: 'assets/svg/icSentImage.svg',
              header: 'Message sent successfully'.tr(),
              body: value.data['custom_message'] ?? 'Message',
              hasButton: true,
              buttonText: 'Ok'.tr(),
              onPressed: () => Navigator.pop(navigatorKey.currentContext!),
            ),
          );
        }
        return value;
      });
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<BookDetails> getBookDetails(int bookId) async {
    BookDetails bookDetails = BookDetails();
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'books/$bookId',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      );

      if (response.statusCode == 200) {
        print(response.statusCode);
        final book = json.decode(json.encode(response.data));
        bookDetails = BookDetails.fromJson(book);
        return bookDetails;
      }
      return bookDetails;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future reportAnError(
    int? id,
    String? type,
    String? typeReport,
    TextEditingController? controller,
    int? commentId,
  ) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    m_part.FormData data = m_part.FormData.fromMap({
      'note': controller!.text,
      'related_id': id,
      'source': 'app',
      'type': type,
      'type_report': typeReport,
      'comment_id': commentId ?? null
    });

    try {
      Future<m_part.Response> response = httpClient
          .post(
        baseUrl + 'reports',
        data: data,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      )
          .then((m_part.Response value) async {
        if (value.statusCode == 200) {
          await showDialog(
            context: navigatorKey.currentContext!,
            builder: (BuildContext builder) => CustomDialog(
              assetPath: 'assets/svg/icSentImage.svg',
              header: 'Report Sent Done'.tr(),
              body: '',
              hasButton: true,
              buttonText: 'Ok'.tr(),
              onPressed: () => Navigator.pop(navigatorKey.currentContext!),
            ),
          );
        }
        return value;
      });
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future CommentForBookOrProdcast(
    int? type,
    int? id,
    int? rate,
    TextEditingController? controller,
  ) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    m_part.FormData data = m_part.FormData.fromMap({
      'note': controller!.text,
      'related_id': id,
      'source': 'app',
      'rate': rate,
    });

    try {
      Future<m_part.Response> response = httpClient
          .post(
            baseUrl + 'user-reports/create/comment/$type',
            data: data,
            options: Options(
              maxRedirects: 1,
              headers: {
                'accept': 'application/json',
                'Content-Type': 'application/json',
              },
            ),
          )
          .then((m_part.Response value) => value);
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<Comments> getCommentWithPagination(
      int? id, int? type, int pageSize, int pageIndex) async {
    Comments comments = Comments();
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      m_part.Response response = await httpClient.get(
        baseUrl + 'user-reports/$id',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
        queryParameters: {'type': type, 'limit': pageSize, 'offset': pageIndex},
      );
      print('pageSize= ${pageSize} ::::::: ${pageIndex}');
      if (response.statusCode == 200) {
        final comment = json.decode(json.encode(response.data));
        comments = Comments.fromJson(comment);
        print(response.statusCode);
      }
      return comments;
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future editComment(
    int? id,
    String? commentText,
    String? commentTime,
    int? rate,
    int? bookId,
  ) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    m_part.FormData data = m_part.FormData.fromMap({
      'note': commentText,
      'updated_at': commentTime,
      'rate': rate,
    });

    try {
      Future<m_part.Response> response = httpClient.post(
        baseUrl + 'user-reports/$id/$bookId',
        data: data,
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      );
    } on DioError {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text('Update Comment Expired'.tr()),
          backgroundColor: Colors.red,
        ),
      );
    }
  }

  Future deleteComment(int? id, int? bookId) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    try {
      Future<m_part.Response> response = httpClient
          .delete(
        baseUrl + 'user-reports/$id/$bookId',
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      )
          .then((m_part.Response value) {
        print(value.statusCode);
        return value;
      });
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future addToFavOrWishList(int? id, String? type) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    try {
      Future<m_part.Response> response = httpClient.post(
        baseUrl + 'books/$id/user-action',
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
        queryParameters: {'type': type},
      ).then((m_part.Response value) {
        print(value.statusCode);
        print(value.data);
        return value;
      });
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future commentLikeOrDislike(int? commentId, int? bookId) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    try {
      Future<m_part.Response> response = httpClient
          .post(
        baseUrl + 'user-reports/like-comment/$commentId/$bookId',
        options: Options(
          maxRedirects: 1,
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
          },
        ),
      )
          .then((m_part.Response value) {
        print(value.statusCode);
        print(value.data);
        return value;
      });
    } on DioError catch (e) {
      return e.response!.data;
    }
  }

  Future<Contributors> getFollowingList(int? roleId) async {
    Contributors following = Contributors();
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');

    try {
      Response<dynamic> response = await httpClient.get(
        baseUrl + 'contributors/followed',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'token': token,
            'Authorization': 'bearer $token',
          },
        ),
        queryParameters: {'role_id': roleId, 'limit': 15, 'offset': 0},
      );

      if (response.statusCode == 200) {
        print(response.statusCode);
        final dynamic follow = json.decode(json.encode(response.data));
        following = Contributors.fromJson(follow);
        return following;
      } else {}
      return following;
    } on DioError catch (e) {
      log(e.response.toString());
      return e.response!.data;
    }
  }

  Future<int> putBookmark(
    PutMarkDto param,
    int bookId,
    int fileId,
  ) async {
    int? statusCode;
    try {
      print(param.toJson());
      m_part.Response response = await httpClient.post(
        baseUrl + 'books/${bookId}/file/${fileId}/bookmark',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
        data: param.toJson(),
      );
      print(response.statusCode ?? 'NO RESPONSE');
      if (response.statusCode == 200) {
        ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
          SnackBar(
            content: Text(response.data['custom_message'] ?? 'NP'),
            backgroundColor: Colors.green,
            duration: const Duration(milliseconds: 500),
          ),
        );
        return statusCode ?? 2;
      }
    } on DioError catch (e) {
      ScaffoldMessenger.of(navigatorKey.currentContext!).showSnackBar(
        SnackBar(
          content: Text(e.response!.data['custom_message'] ?? 'NP'),
          backgroundColor: Colors.red,
        ),
      );
    }
    return statusCode ?? 2;
  }

  Future<int> postAudioToLibrary(
    AddToLibraryDto param,
  ) async {
    int? statusCode;
    try {
      print(param.toJson());
      m_part.Response response = await httpClient.post(
        baseUrl + 'libraries/${param.related_id}/chapters/${param.chapter_id}',
        options: Options(
          headers: {
            'accept': 'application/json',
            'Content-Type': 'application/json',
            'lang': navigatorKey.currentContext!.locale.toString()
          },
        ),
        queryParameters: {
          'type': param.type,
          'percentage': param.percentage,
        },
        data: param.toJson(),
      );
      print(response.statusCode ?? 'NO RESPONSE');
      if (response.statusCode == 200) {
        return statusCode ?? 2;
      }
    } on DioError catch (e) {
      return e.response!.statusCode!;
    }
    return statusCode ?? 2;
  }

  Future<HomeStripsModel> getHomeStrips(int stripId) async {
    final RxSharedPreferences rxPrefs = RxSharedPreferences.getInstance();
    final String? token = await rxPrefs.getString('token');
    try {
      print(
        baseUrl + 'strips/${stripId}/books',
      );
      Response<dynamic> response = await httpClient.get(
        baseUrl + 'strips/${stripId}/books',
        options: Options(
          headers: {
            'accept': 'application/json',
          },
        ),
        queryParameters: {'limit': 15, 'offset': 0},
      );
      if (response.statusCode == 200) {
        final validMap = json.decode(json.encode(response.data));
        HomeStripsModel resp = HomeStripsModel.fromJson(validMap);

        return resp;
      }
      return response.data;
    } on DioError catch (e) {
      log(e.response!.data.toString());
      return e.response!.data;
    }
  }
}