import 'package:dio/dio.dart';
import 'package:ftc_mobile_app/ftc_mobile_app.dart';
import 'package:ftc_mobile_app/models/clients/PBSPlanModel.dart';
import 'package:ftc_mobile_app/models/clients/allCareNotes/AllCareNotesListResponse.dart';
import 'package:ftc_mobile_app/models/clients/allCareNotes/CareNoteData.dart';
import 'package:ftc_mobile_app/models/clients/body_points_category.dart';
import 'package:ftc_mobile_app/models/clients/consent_details_model.dart';
import 'package:ftc_mobile_app/models/clients/memoryListResponse/MemoryListResponse.dart';
import 'package:ftc_mobile_app/models/clients/memoryListResponse/MemoryListResponseData.dart';
import 'package:ftc_mobile_app/models/clients/recent_incidents_model.dart';
import 'package:ftc_mobile_app/models/clients/add_pbs_plan_model.dart';
import 'package:ftc_mobile_app/models/clients/riskAssessmentResponse/GetRiskAssessmentResponse.dart';
import 'package:ftc_mobile_app/models/clients/riskAssessmentResponse/RiskAssessmentData.dart';
import 'package:ftc_mobile_app/utilities/enums/api_method.dart';
import 'package:ftc_mobile_app/utilities/extensions/custom_extensions.dart';
import '../models/appointmentsListResponse/AppointmentsListResponse.dart';
import '../models/clients/HealthIssuesDetailsModel.dart';
import '../models/clients/allClientsList/AllClientsResponse.dart';
import '../models/clients/documents_list_model.dart';
import '../models/create_care_plan_request.dart';

class ClientService {
  static final ClientService _instance = ClientService._private();

  ClientService._private();

  factory ClientService() {
    return _instance;
  }

  final HttpRequestClient _httpClient = HttpRequestClient();

  Future<AllClientsResponse> getUserDetails() async {
    Map<String, dynamic> requestBody = {
      "offset": 0,
      "limit": 1,
      "query": {
        "critarion": {
          "active": true,
          // "_id": LocalStorageManager.userId,
          "_id": "659535b08d2973ab265f1091"
        },
      },
    };

    ResponseModel responseModel = await _httpClient.safeApiCall(
      method: ApiMethod.post,
      url: WebUrls.getServiceUsersListUrl,
      body: requestBody,
    );
    if ((responseModel.statusCode ~/ 100) == 2) {
      final resp = AllClientsResponseData.fromJson(responseModel.data);
      return AllClientsResponse(success: true, data: resp);
    } else {
      return AllClientsResponse(success: false, message: responseModel.statusDescription);
    }
  }

  Future<dynamic> addConsentDetails(
      {required String description, required String staffId}) async {
    Map<String, dynamic> requestBody = {
      "staffId": staffId,
      "active": true,
      "description": description,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.addConsentUrl,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .contains("Consent Template added successfully")) {
      if (responseModel.data is List && responseModel.data.length > 0) {
        ConsentDetailsModel consentDetailsModel =
            ConsentDetailsModel.fromJson(responseModel.data[0]);
        return consentDetailsModel;
      } else {
        ConsentDetailsModel consentDetailsModel =
            ConsentDetailsModel.fromJson(responseModel.data);
        return consentDetailsModel;
      }
      // return true;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> getConsentDetails({required String staffId}) async {
    Map<String, dynamic> requestBody = {
      "sortproperty": "createdAt",
      "sortorder": -1,
      "staffId": staffId,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getConsentListUrl,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      List<ConsentDetailsModel> consentList = [];
      if (responseModel.data is List) {
        for (var singleEntry in responseModel.data) {
          consentList.add(ConsentDetailsModel.fromJson(singleEntry));
        }
      } else {}
      return consentList;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> deleteConsent({required String consentId}) async {
    Map<String, dynamic> requestBody = {
      "templateId": consentId,
    };
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.deleteConsentUrl,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase() ==
            "template removed successfully") {
      return true;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> updateConsentDetails(
      {required String description, required String consentId}) async {
    Map<String, dynamic> requestBody = {
      "templateId": consentId,
      "description": description,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.updateConsentUrl,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription == "Updated successfully") {
      return true;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<AllClientsResponse> getServiceUsersList({
    String searchText = "",
    int limit = 20,
    int offset = 0,
  }) async {
    Map<String, dynamic> requestBody = {
      "sortproperty": "createdAt",
      "sortorder": -1,
      "offset": offset,
      "limit": limit,
      "searchText": searchText,
      "query": {
        "critarion": {"role": "serviceuser"}
      }
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getServiceUsersListUrl,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      final resp = AllClientsResponseData.fromJson(responseModel.data);
      return AllClientsResponse(success: true, data: resp);
    } else {
      return AllClientsResponse(
        success: false,
        message: responseModel.statusDescription,
      );
    }
  }

  Future<AllClientsResponse> getAllUsersList({
    String searchText = "",
    int limit = 20,
    int offset = 0,
  }) async {
    Map<String, dynamic> requestBody = {
      "sortproperty": "createdAt",
      "sortorder": -1,
      "offset": 0,
      "query": {
        "critarion": {"active": true, "role": "staffmember"}
      }
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.listAllUsers,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      final resp = AllClientsResponseData.fromJson(responseModel.data);

      // List<ServiceUserModel> serviceUsers = [];
      // for (var singleUser in responseModel.data['serviceUsers']) {
      //   serviceUsers.add(ServiceUserModel.fromJson(singleUser));
      // }
      return AllClientsResponse(success: true, data: resp);
    } else {
      return AllClientsResponse(
        success: false,
        message: responseModel.statusDescription,
      );
    }
  }

  Future<dynamic> getBodyPointsCategoryList() async {
    Map<String, dynamic> requestBody = {};

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getBodyPointsCategoryListURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("category list")) {
      List<BodyPointsCategory> bodyPointsCategoryList = [];
      for (var singleUser in responseModel.data) {
        bodyPointsCategoryList.add(BodyPointsCategory.fromJson(singleUser));
      }
      return bodyPointsCategoryList;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> addHealthIssue({
    required String userId,
    required String category,
    required String healthNote,
    required String complaint,
  }) async {
    Map<String, dynamic> requestBody = {
      "userId": userId,
      "category": category,
      "healthNote": healthNote,
      "complaint": complaint,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.addHealthIssuesURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      return HealthIssueDetailsModel.fromJson(responseModel.data);
    } else {
      return responseModel.statusDescription;
    }
  }

  Future<dynamic> getHealthIssues({required String userId}) async {
    // String userJson = _sessionManagement.getSessionToken(
    //   tokenKey: SessionKeys.kUserModelKey,
    // );
    // UserModel userModel = UserModel.fromJson(json.decode(userJson));

    Map<String, dynamic> requestBody = {
      "userId": userId,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getHealthIssuesListURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("health issues list")) {
      List<HealthIssueDetailsModel> healthIssuesDetailsList = [];
      for (var singleHealthIssue in responseModel.data) {
        healthIssuesDetailsList
            .add(HealthIssueDetailsModel.fromJson(singleHealthIssue));
      }
      return healthIssuesDetailsList;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> updateHealthIssueData({
    required String issueId,
    required String categoryId,
    bool? status,
    String? complaint,
    String? healthNote,
  }) async {
    Map<String, dynamic> requestBody = {
      "issueId": issueId,
      "category": categoryId,
    };

    if (status != null) {
      requestBody['status'] = status;
    }

    if (complaint.isNotNullOrEmpty()) {
      requestBody['complaint'] = complaint;
    }

    if (healthNote.isNotNullOrEmpty()) {
      requestBody['healthNote'] = healthNote;
    }

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.updateHealthIssueURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      return BodyPointsCategory.fromJson(responseModel.data);
    } else {
      return responseModel.statusDescription;
    }
  }

  Future<dynamic> healthIssueChildCategory({required String categoryId}) async {
    Map<String, dynamic> requestBody = {
      "categoryId": categoryId,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getHealthIssueChildCategoryListURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      List<SubCat> subCatList = [];
      for (var singleSubCat in responseModel.data) {
        subCatList.add(SubCat.fromJson(singleSubCat));
      }
      return subCatList;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> addRecentIncidentService(
      {required String userId,
      required String incidentTitle,
      required String note,
      required int incidentDate}) async {
    Map<String, dynamic> requestBody = {
      "userId": userId,
      "note": note,
      "incidentTitle": incidentTitle,
      "incidentDate": incidentDate,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.addRecentIncidentServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      RecentIncidentsModel recentIncidentsModel =
          RecentIncidentsModel.fromJson(responseModel.data);
      return recentIncidentsModel;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> getRecentIncidentsListService(
      {required String userId}) async {
    Map<String, dynamic> requestBody = {
      "query": {
        "critarion": {
          "userId": userId,
          "active": true,
        },
      },
      "sortProperty": "createdAt",
      "sortOrder": -1,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getRecentIncidentsListServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      List<RecentIncidentsModel> recentIncidentsModelList = [];
      if (responseModel.data is List) {
        for (var data in responseModel.data) {
          recentIncidentsModelList.add(RecentIncidentsModel.fromJson(data));
        }
        return recentIncidentsModelList;
      } else {
        return responseModel.statusDescription;
      }
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> updateRecentIncidentService({
    required String incidentId,
    required String incidentTitle,
    required String incidentNote,
    required int incidentDate,
  }) async {
    Map<String, dynamic> requestBody = {
      "id": incidentId,
      "incidentDate": incidentDate,
      "incidentTitle": incidentTitle,
      "note": incidentNote,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.updateRecentIncidentServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      if (responseModel.data is Map<String, dynamic>) {
        return RecentIncidentsModel.fromJson(responseModel.data);
      } else {
        return responseModel.statusDescription;
      }
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> deleteRecentIncident({required String incidentId}) async {
    Map<String, dynamic> requestBody = {
      "id": incidentId,
    };
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.deleteRecentIncidentUrl,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("success")) {
      if (responseModel.data is Map<String, dynamic>) {
        return RecentIncidentsModel.fromJson(responseModel.data);
      } else {
        return responseModel.statusDescription;
      }
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> addPbsPlanService(
      {required String userId,
      required String staffId,
      required String postIncidentSupport,
      required String reactiveStartegies,
      required String secondaryPrevention,
      required String managementOfBehaviorPlan,
      required String aboutPlan}) async {
    Map<String, dynamic> requestBody = {
      "userId": userId,
      "staffId": staffId,
      "postIncidentSupport": postIncidentSupport,
      "reactiveStartegies": reactiveStartegies,
      "secondaryPrevention": secondaryPrevention,
      "managementOfBehaviorPlan": managementOfBehaviorPlan,
      "aboutPlan": aboutPlan,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.addPbsPlanServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("added")) {
      print(
          '---------data is not null returning PBSListDataJson model from service');
      AddPBSPlanModel addPBSPlanModel =
          AddPBSPlanModel.fromJson(responseModel.data);
      return addPBSPlanModel;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> updatePbsPlanService(
      {required String id,
      required String userId,
      required String staffId,
      required String postIncidentSupport,
      required String reactiveStartegies,
      required String secondaryPrevention,
      required String managementOfBehaviorPlan,
      required String aboutPlan}) async {
    Map<String, dynamic> requestBody = {
      "userId": userId,
      "staffId": staffId,
      "postIncidentSupport": postIncidentSupport,
      "reactiveStartegies": reactiveStartegies,
      "secondaryPrevention": secondaryPrevention,
      "managementOfBehaviorPlan": managementOfBehaviorPlan,
      "aboutPlan": aboutPlan,
      "id": id,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.updatePbsPlanServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("pbsplan updated")) {
      return AddPBSPlanModel.fromJson(responseModel.data);
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> getPbsPlanListService({required String userId}) async {
    Map<String, dynamic> requestBody = {
      "query": {
        "critarion": {"userId": userId}
      },
      "sortProperty": "createdAt",
      "sortOrder": -1
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getPbsPlanServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("pbs plan list")) {
      PBSListDataJson pbsDataJsonModel = PBSListDataJson.empty();
      if (responseModel.data != null) {
        pbsDataJsonModel = PBSListDataJson.fromJson(responseModel.data);
        return pbsDataJsonModel;
      } else {
        return responseModel.statusDescription;
      }
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> deletePbsPlanService({required String pbsId}) async {
    Map<String, dynamic> requestBody = {
      "pbsId": pbsId,
    };
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.deletePbsPlanServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription.toLowerCase().contains("deleted")) {
      return true;
      // if(responseModel.data is Map<String,dynamic>){
      //   return RecentIncidentsModel.fromJson(responseModel.data);
      // }
      // else{
      //   return responseModel.statusDescription;
      // }
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> getDocumentListService(
      {required String serviceUserId}) async {
    Map<String, dynamic> requestBody = {
      "sortProperty": "createdAt",
      "sortOrder": -1,
      // "offset": 0,
      // "limit": 10,
      "query": {
        "critarion": {"userId": serviceUserId}
      }
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getDocumentsListServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("document list")) {
      if (responseModel.data != null) {
        return DocumentsListModel.fromJson(responseModel.data);
      } else {
        return DocumentsListModel.empty();
      }
    } else {
      return responseModel.statusDescription;
    }
  }

  Future<dynamic> addDocumentService({
    required String userId,
    required String docPath,
    required String docDetails,
    required String title,
    required String addedBy,
  }) async {
    if (docPath.isEmpty) {
      return "Please select document file first";
    }

    final resp = await uploadDocumentService(docPath: docPath);

    if (resp is! String) {
      return;
    }

    Map<String, dynamic> requestBody = {
      "userId": userId,
      "docPath": resp,
      "details": docDetails,
      "title": title,
      "addedBy": addedBy,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.addDocumentServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        (responseModel.statusDescription
                .toLowerCase()
                .contains("dcoument added") ||
            responseModel.statusDescription
                .toLowerCase()
                .contains("document added"))) {
      print(
          '---------data is not null returning Dcoument Added model from service');
      DocumentModel documentModel = DocumentModel.fromJson(responseModel.data);
      return documentModel;
    } else {
      responseModel.statusDescription;
    }
  }

  Future<dynamic> updateDocumentService({
    required String userId,
    required String docId,
    required String docPath,
    required String docDetails,
    required String title,
    required String addedBy,
  }) async {
    Map<String, dynamic> requestBody = {
      "userId": userId,
      "documentId": docId,
      "docPath": docPath,
      "details": docDetails,
      "title": title,
      "addedBy": addedBy,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.updateDocumentServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      return DocumentModel.fromJson(responseModel.data);
    } else {
      return responseModel.statusDescription;
    }
  }

  Future<dynamic> deleteDocumentService({required String docId}) async {
    Map<String, dynamic> requestBody = {
      "documentId": docId,
    };
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.deleteDocServiceURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("document removed successfully")) {
      if (responseModel.data['deletedCount'] == 0) {
        return true;
      } else {
        return false;
      }
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> uploadDocumentService({
    required String docPath,
  }) async {
    final files = <String, String>{"attachements": docPath};
    ResponseModel responseModel = await _httpClient.postMultipartRequest(
      files: files,
      url: WebUrls.uploadDocServiceURL,
    );

    if (responseModel.statusDescription
        .toLowerCase()
        .contains("file uploaded successfully")) {
      return responseModel.data[0]
          ["fileNameInDirectory"]; // returning file path from response
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> createCarePlan({
    required CreateCarePlanRequest request,
  }) async {
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.createCarePlanURL,
      requestBody: request.toJson(),
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );

    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      return responseModel;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> getCarePlansList(
      {required String serviceUserId, int limit = 20, int offset = 0}) async {
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getCarePlansListURL,
      requestBody: {
        "query": {
          "critarion": {"userId": serviceUserId, "active": true}
        },
        "sortproperty": "eventDateTime",
        "sortorder": -1,
        "limit": limit,
        "offset": offset
      },
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );

    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      print("getCarePlansList responseModel: ${responseModel.toJson()}");
      return AllCareNotesListResponse.success()
        ..message = responseModel.statusDescription
        ..data = CareNoteData.fromJson(responseModel.data);
    } else {
      return responseModel.statusDescription;
    }
  }

  Future<AppointmentsListResponse> getAppointmentsList(
      {required String serviceId,
      required int startDate,
      required int endDate}) async {
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getAppointmentsByDate,
      requestBody: {
        "userId": serviceId,
        "startDate": startDate,
        "endDate": endDate,
      },
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );

    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      if (responseModel.data is List &&
          (responseModel.data as List).isNotNullOrEmpty()) {
        return AppointmentsListResponse(
            success: true,
            data: (responseModel.data as List)
                .map((e) => AppointmentsListResponseData.fromJson(e))
                .toList());
      }

      return AppointmentsListResponse(success: true, data: []);
      // print("getCarePlansList responseModel: ${responseModel.toJson()}");
      // return AllCareNotesListResponse.success()
      //   ..message = responseModel.statusDescription
      //   ..data = CareNoteData.fromJson(responseModel.data);
    } else {
      return AppointmentsListResponse(
          success: false, message: responseModel.statusDescription);
    }
  }

  Future<GetRiskAssessmentResponse> getRiskAssessments(
      {required String serviceUserId}) async {
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getRiskAssesments,
      requestBody: {"userId": serviceUserId},
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );

    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      if (responseModel.data is List &&
          (responseModel.data as List).isNotNullOrEmpty()) {
        return GetRiskAssessmentResponse(
            success: true,
            data: (responseModel.data as List)
                .map((e) => RiskAssessmentData.fromJson(e))
                .toList());
      }

      return GetRiskAssessmentResponse(success: true, data: []);
    } else {
      return GetRiskAssessmentResponse(
          success: false, message: responseModel.statusDescription);
    }
  }

  Future<MemoryListResponse> getMemoryList(
      {required String serviceUserId}) async {
    final req = {
      "query": {
        "critarion": {"userId": serviceUserId}
      },
      "sortproperty": "createdAt",
      "sortorder": -1
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.getMemoryList,
      requestBody: req,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );

    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      if (responseModel.data is Map) {
        return MemoryListResponse(
            success: true,
            data: MemoryListResponseData.fromJson(responseModel.data));
      }

      return MemoryListResponse(success: false);
    } else {
      return MemoryListResponse(
          success: false, message: responseModel.statusDescription);
    }
  }

  Future<dynamic> createRiskAssesments(
      {required RiskAssessmentData data}) async {
    final req = {
      "userId": data.userId,
      "hazard": data.hazard,
      "personsExposedToHazard": data.personsExposedToHazard,
      "riskIdentified": data.riskIdentified,
      "coldMeasureRequired": data.coldMeasureRequired,
      "pureRiskRating": {
        "c": data.pureRiskRating?.c ?? 1,
        "l": "${data.pureRiskRating?.l ?? 1}",
        "r": "${data.pureRiskRating?.r ?? 1}",
      },
      "inPlace": {
        "y": "${data.inPlace?.y ?? 1}",
        "n": "${data.inPlace?.n ?? 1}",
      },
      "residualRiskRating": {
        "c": "${data.residualRiskRating?.c ?? 1}",
        "l": "${data.residualRiskRating?.l ?? 1}",
        "r": "${data.residualRiskRating?.r ?? 1}",
      }
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.createRiskAssesments,
      requestBody: req,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );

    if ((responseModel.statusCode ~/ 100) == 2) {
      return true;
    } else {
      return responseModel.statusDescription;
    }
  }

  Future<dynamic> uploadMemoryBoxFile({
    required String filePath,
  }) async {
    final formData = FormData();
    formData.files.add(MapEntry(
      "file",
      MultipartFile.fromFileSync(filePath),
    ));

    ResponseModel responseModel = await _httpClient.safeFormDataRequest(
      url: WebUrls.uploadMemoryBoxFile,
      body: formData,
    );

    print("responseModel is : ${responseModel.toJson()}");

    if ((responseModel.statusCode ~/ 100) == 2) {
      //Success response
      return responseModel.data; // returning file path from response
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  //return true if success else error message string
  Future<dynamic> addMemoryBoxFile({
    required String userId,
    required String filePath,
    required String noteDetails,
  }) async {
    if (filePath.isEmpty) {
      return "Please select file first";
    }

    final resp = await uploadMemoryBoxFile(filePath: filePath);
    if (resp is Map) {
      return resp['message'];
    }

    // String userJson = LocalStorageManager.getSessionToken(
    //   tokenKey: LocalStorageKeys.kUserModelKey,
    // );
    // UserModel userModel = UserModel.fromJson(json.decode(userJson));

    Map<String, dynamic> requestBody = {
      "addedBy": LocalStorageManager.userId,
      "userId": userId,
      "filePath": resp,
      "note": noteDetails,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.addMemoryBox,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      // DocumentModel documentModel = DocumentModel.fromJson(responseModel.data);
      return true;
    } else {
      responseModel.statusDescription;
    }
  }

  Future<dynamic> updateMemoryBoxFile({
    required String userId,
    required String id,
    required String filePath,
    required String noteDetails,
  }) async {
    dynamic resp;

    if (filePath.isNotEmpty) {
      //upload file
      resp = await uploadMemoryBoxFile(filePath: filePath);

      // On error
      if (resp is Map) {
        return resp['message'];
      }
    }

    // String userJson = LocalStorageManager.getSessionToken(
    //   tokenKey: LocalStorageKeys.kUserModelKey,
    // );
    // UserModel userModel = UserModel.fromJson(json.decode(userJson));

    Map<String, dynamic> requestBody = {
      "addedBy": LocalStorageManager.userId,
      "userId": userId,
      "memoryBoxId": id,
    };

    if (resp is String) {
      requestBody['filePath'] = resp;
    }

    if (noteDetails.isNotEmpty) {
      requestBody['note'] = noteDetails;
    }

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.updateMemoryBox,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      // return DocumentModel.fromJson(responseModel.data);
      return true;
    } else {
      return responseModel.statusDescription;
    }
  }
}