import 'dart:io';

import 'package:dio/dio.dart';
import 'package:ftc_mobile_app/ftc_mobile_app.dart';
import 'package:ftc_mobile_app/models/chat/ChatModel.dart';
import 'package:ftc_mobile_app/models/chat/add_group_message_model.dart';
import 'package:ftc_mobile_app/models/chat/all_group_messages_model.dart';
import 'package:ftc_mobile_app/models/chat/all_single_chat_message_model.dart';
import 'package:ftc_mobile_app/models/chat/combined_last_messages_model_class.dart';
import '../models/chat/single_chat.dart';

enum MessageType { file, message }

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

  ChatService._private();

  factory ChatService() {
    return _instance;
  }

  final HttpRequestClient _httpClient = HttpRequestClient();

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

    ResponseModel responseModel = await _httpClient.safeFormDataRequest(
      url: WebUrls.uploadMessageAttachmentsURL,
      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,
      };
    }

    // final files = <String, String>{"attachment": filePath};
    // ResponseModel responseModel = await _httpClient.postMultipartRequest(
    //   files: files,
    //   url: WebUrls.uploadMessageAttachmentsURL,
    // );
    //
    // if (responseModel.statusCode ~/ 100 == 2) {
    //   print("got data as: ${responseModel.data}");
    //   return responseModel.data;
    // } else {
    //   return {
    //     "message": responseModel.statusDescription,
    //   };
    // }
  }

  Future<dynamic> addSingleMessage({
    required String message,
    required MessageType messageType,
    File? file,
    required String senderId,
    required String receiverId,
  }) async {
    Map<String, dynamic> requestBody = {
      "from": senderId,
      "to": receiverId,
      "message": message,
      "messageType": messageType.name,
    };

    if (messageType == MessageType.file) {
      if (file == null) {
        return {
          "message": "Please select file to upload",
        };
      }

      final resp = await _uploadFile(filePath: file.path);
      print("upload resp: $resp");
      if (resp is String) {
        requestBody['message'] = resp; //overriding message in case of file send
        requestBody['filePath'] = resp;
      } else {
        return {
          "message": "Failed to send file",
        };
      }
    }

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

  Future<dynamic> addGroupMessageService(
      {required String message,
      required MessageType messageType,
      File? file,
      required String groupId,
      required String userId}) async {
    Map<String, dynamic> requestBody = {
      "groupId": groupId,
      "userId": userId,
      "message": message,
      "messageType": messageType.name,
    };

    if (messageType == MessageType.file) {
      if (file == null) {
        return {
          "message": "Please select file to upload",
        };
      }

      final resp = await _uploadFile(filePath: file.path);
      print("upload resp: $resp");
      if (resp is String) {
        requestBody['message'] = resp; //overriding message in case of file send
        requestBody['filePath'] = resp;
      } else {
        return {
          "message": "Failed to send file",
        };
      }
    }

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

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

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.combinedLastMessageURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("group messages")) {
      if (responseModel.data is List && responseModel.data.length > 0) {
        CombinedMessageModel combinedMessageModel =
            CombinedMessageModel.fromJson(responseModel.data[0]);
        return combinedMessageModel;
      } else {
        CombinedMessageModel combinedMessageModel =
            CombinedMessageModel.fromJson(responseModel.data);
        return combinedMessageModel;
      }
      // return true;
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> allGroupMessages({
    required int sortOrder,
    required int offset,
    required int limit,
    required String groupId,
    required bool isDeleted,
  }) async {
    Map<String, dynamic> requestBody = {
      "sortProperty": "createdAt",
      "sortOrder": sortOrder,
      "offset": offset,
      "limit": limit,
      "query": {
        "critarion": {"groupId": groupId, "isDeleted": false}
      }
    };
    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.allGroupMessagesURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      if (responseModel.data is List && responseModel.data.length > 0) {
        List<AllGroupMessages> listOfMessages = [];
        for (final item in responseModel.data) {
          listOfMessages.add(AllGroupMessages.fromJson(item));
        }
        return listOfMessages;
      } else {
        return <AllGroupMessages>[];
      }
    } else {
      return responseModel.statusDescription;
    }
  }

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

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.allSingleChatMessagesURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 &&
        responseModel.statusCode <= 230 &&
        responseModel.statusDescription
            .toLowerCase()
            .contains("all messages load")) {
      if (responseModel.data is List && responseModel.data.length > 0) {
        List<AllSingleChatMessages> listOfMessages = [];
        for (var item in responseModel.data) {
          listOfMessages.add(AllSingleChatMessages.fromJson(item));
        }
        return listOfMessages;
      } else {
        AllSingleChatMessages allSingleChatMessages =
            AllSingleChatMessages.fromJson(responseModel.data);
        return allSingleChatMessages;
      }
    } else {
      return {
        "message": responseModel.statusDescription,
      };
    }
  }

  Future<dynamic> allSingleUsersChatMessagesServerAdmin({
    required String to,
    required String from,
  }) async {
    Map<String, dynamic> requestBody = {
      "to": to,
      "from": from,
    };

    ResponseModel responseModel = await _httpClient.customRequest(
      "POST",
      url: WebUrls.allSingleChatMessagesServiceAdminURL,
      requestBody: requestBody,
      requestHeader: {'Content-Type': 'application/json'},
      isBearerHeaderRequired: true,
      isBearer: true,
    );
    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
      if (responseModel.data is List && responseModel.data.length > 0) {
        List<ChatModel> listOfMessages = [];
        for (final item in responseModel.data) {
          listOfMessages.add(ChatModel.fromJson(item));
        }
        return listOfMessages;
      } else {
        // AllSingleUsersChats allSingleUsersChats =
        //     AllSingleUsersChats.fromJson(responseModel.data);
        return <ChatModel>[];
      }
    } else {
      return responseModel.statusDescription;
    }
  }
}