// ignore_for_file: use_build_context_synchronously

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

import 'package:easy_localization/easy_localization.dart';
import 'package:flutter/cupertino.dart';
import 'package:mc_common_app/classes/app_state.dart';
import 'package:mc_common_app/classes/consts.dart';
import 'package:mc_common_app/extensions/string_extensions.dart';
import 'package:mc_common_app/generated/locale_keys.g.dart';
import 'package:mc_common_app/main.dart';
import 'package:mc_common_app/models/chat_models/chat_message_model.dart';
import 'package:mc_common_app/models/general_models/generic_resp_model.dart';
import 'package:mc_common_app/models/requests_models/provider_offers_model.dart';
import 'package:mc_common_app/repositories/chat_repo.dart';
import 'package:mc_common_app/repositories/request_repo.dart';
import 'package:mc_common_app/services/common_services.dart';
import 'package:mc_common_app/utils/enums.dart';
import 'package:mc_common_app/utils/utils.dart';
import 'package:mc_common_app/view_models/ad_view_model.dart';
import 'package:mc_common_app/view_models/base_view_model.dart';
import 'package:mc_common_app/view_models/requests_view_model.dart';
import 'package:provider/provider.dart';
import 'package:signalr_core/signalr_core.dart';

class ChatVM extends BaseVM {
  final ChatRepo chatRepo;
  final RequestRepo requestRepo;
  final CommonAppServices commonServices;

  ChatVM({required this.chatRepo, required this.requestRepo, required this.commonServices});

  HubConnection? hubConnection;
  bool _isSubscribed = false; // Track if listeners are subscribed

  String chatMessageText = "";

  updateChatMessageText(String value) {
    chatMessageText = value;
  }

  clearChatMessageText() {
    chatMessageText = "";
    notifyListeners();
  }

  int latestOfferId = 0;

  updateLatestOfferId(var value) {
    latestOfferId = value;
    notifyListeners();
  }

  bool acknowledgePaymentToMowaterStatus = false;

  updateAcknowledgePaymentToMowaterStatus(var value) {
    acknowledgePaymentToMowaterStatus = value;
    notifyListeners();
  }

  bool isUserOnChatScreen = false;

  final ScrollController scrollController = ScrollController();

  void scrollChatDown() {
    if (!isUserOnChatScreen) {
      return;
    }
    if (scrollController.hasClients) {
      scrollController.animateTo(
        scrollController.position.maxScrollExtent + 200, // for the text field
        duration: const Duration(seconds: 1),
        curve: Curves.fastOutSlowIn,
      );
    }
  }

  List<OfferRequestCommentModel> dealOptionsModelList = [
    OfferRequestCommentModel(
      index: 0,
      isSelected: false,
      title: LocaleKeys.dealCompleted.tr(),
    ),
    OfferRequestCommentModel(
      index: 1,
      isSelected: false,
      title: LocaleKeys.theDealNotCompleted.tr(),
    ),
  ];

  updateIsSelectedInDealOptionsModelList(int index, bool value) {
    for (var element in dealOptionsModelList) {
      element.isSelected = false;
    }
    dealOptionsModelList[index].isSelected = true;
    notifyListeners();
  }

  List<int> indexesForCancelSpecialCarOffer = [0, 1, 6, 10];
  List<int> indexesForCancelSparePartOffer = [2, 10];
  List<int> indexesForRejectOffer = [3, 4, 10];
  List<int> indexesForDealNotCompleted = [7, 4, 8, 9, 10];

  List<OfferRequestCommentModel> offerRejectModelList = [
    OfferRequestCommentModel(
      index: 0,
      isSelected: true,
      title: LocaleKeys.dealOutsideApp.tr(),
    ),
    OfferRequestCommentModel(
      index: 1,
      isSelected: false,
      title: LocaleKeys.noAgreementCustomer.tr(),
    ),
    OfferRequestCommentModel(
      index: 2,
      isSelected: false,
      title: LocaleKeys.itemNoLongerAvailable.tr(),
    ),
    OfferRequestCommentModel(
      index: 3,
      isSelected: true,
      title: LocaleKeys.changedMind.tr(),
    ),
    OfferRequestCommentModel(
      index: 4,
      isSelected: false,
      title: LocaleKeys.veryHighPrice.tr(),
    ),
    OfferRequestCommentModel(
      index: 5,
      isSelected: false,
      title: LocaleKeys.alreadySold.tr(),
    ),
    OfferRequestCommentModel(
      index: 6,
      isSelected: false,
      title: LocaleKeys.customerNotResponding.tr(),
    ),
    OfferRequestCommentModel(
      index: 7,
      isSelected: false,
      title: LocaleKeys.cancelRequest.tr(),
    ),
    OfferRequestCommentModel(
      index: 8,
      isSelected: false,
      title: LocaleKeys.offerNotMatched.tr(),
    ),
    OfferRequestCommentModel(
      index: 9,
      isSelected: false,
      title: LocaleKeys.testTheService.tr(),
    ),
    OfferRequestCommentModel(
      index: 10,
      isSelected: false,
      title: LocaleKeys.otherVar.tr(),
    ),
  ];

  void updateSelectionInOfferRejectModelList(int index) {
    for (var value in offerRejectModelList) {
      value.isSelected = false;
    }
    selectedOfferRequestCommentModel = offerRejectModelList[index];
    offerRejectModelList[index].isSelected = true;
    notifyListeners();
  }

  OfferRequestCommentModel selectedOfferRequestCommentModel = OfferRequestCommentModel(
    index: 0,
    isSelected: true,
    title: LocaleKeys.changedMind.tr(),
  );

  String rejectOfferDescription = "";
  String rejectOfferDescriptionError = "";

  void updateRejectOfferDescription(String value) {
    rejectOfferDescription = value;
    if (value.isNotEmpty) {
      rejectOfferDescriptionError = "";
    }
  }

  //REJECTING OFFER
  bool isRejectOfferButtonValidated() {
    if (selectedOfferRequestCommentModel.index != offerRejectModelList.length - 1) {
      return true;
    }
    bool isValidated = true;
    if (rejectOfferDescription.isEmpty) {
      rejectOfferDescriptionError = GlobalConsts.descriptionError;
      isValidated = false;
    } else {
      rejectOfferDescriptionError = "";
    }

    notifyListeners();

    return isValidated;
  }

  Future<void> onNewMessageReceivedForRequestOffer({required List<ChatMessageModel> messages, bool isMyOwnOffer = false, required RequestsVM requestsVM}) async {
    if (AppState().currentAppType == AppType.customer) {
      for (var currentMessage in messages) {
        logger.i(currentMessage);

        int providerIndex = serviceProviderOffersList.indexWhere((element) => element.providerUserId == currentMessage.senderUserID);
        if (providerIndex != -1) {
          if (currentMessage.chatMessageTypeEnum == ChatMessageTypeEnum.offer) {
            for (var chatMessage in serviceProviderOffersList[providerIndex].chatMessages!) {
              if (chatMessage.chatMessageTypeEnum == ChatMessageTypeEnum.offer && chatMessage.reqOffer!.id == currentMessage.reqOffer!.id) {
                chatMessage.reqOffer!.requestOfferStatusEnum = currentMessage.reqOffer!.requestOfferStatusEnum;
              }
            }
          }
          serviceProviderOffersList[providerIndex].chatMessages!.add(currentMessage);
          scrollChatDown();
        }
      }
    } else {
      for (var currentMessage in messages) {
        logger.i(currentMessage);
        // Where we need to call this function for saving a message in chat we will use receiverUserID and in those cases where received ID is null , it means it is a signal R call
        int requestIndex = -1;
        if (isMyOwnOffer) {
          requestIndex = requestsVM.myFilteredRequests.indexWhere((element) => (element.customerUserID == currentMessage.receiverUserID && element.id == currentMessage.requestID));
        } else {
          requestIndex = requestsVM.myFilteredRequests.indexWhere((element) => (element.customerUserID == currentMessage.senderUserID && element.id == currentMessage.requestID));
        }
        log("requestIndex: $requestIndex");
        if (requestIndex != -1) {
          if (currentMessage.chatMessageTypeEnum == ChatMessageTypeEnum.offer) {
            for (var chatMessage in requestsVM.myFilteredRequests[requestIndex].chatMessages) {
              if (chatMessage.chatMessageTypeEnum == ChatMessageTypeEnum.offer && chatMessage.reqOffer!.id == currentMessage.reqOffer!.id) {
                logger.i("chatMessage reqOfferID: ${chatMessage.reqOffer!.id.toString()}");
                logger.i("currentMessage reqOfferID: ${currentMessage.reqOffer!.id.toString()}");
                chatMessage.reqOffer!.requestOfferStatusEnum = currentMessage.reqOffer!.requestOfferStatusEnum;
              }
            }
          }
          requestsVM.addChatMessagesInRequestsModel(msg: currentMessage, index: requestIndex);
          scrollChatDown();
        }
      }
    }
    notifyListeners();
  }

  void _subscribeToReceiveRequestOfferMessages(BuildContext context) {
    hubConnection!.on(SignalrConsts.receiveMessageRequestOffer, (List<Object?>? arguments) {
      logger.i(arguments);

      if (arguments == null || arguments.isEmpty) return;
      List<ChatMessageModel> chat = [];
      for (var message in arguments) {
        final chatMessage = ChatMessageModel.fromJson(message as Map<String, dynamic>, isForReqOfferImagesURLs: true);
        chat.add(chatMessage);
      }
      onNewMessageReceivedForRequestOffer(messages: chat, requestsVM: context.read<RequestsVM>());
      // Utils.showToast(arguments.toString());
    });
  }

  Future<bool> markMessagesAsRead(BuildContext context, List<int> messageIds, ChatTypeEnum chatTypeEnum) async {
    bool status = false;
    try {
      // Utils.showLoading(context);
      status = await chatRepo.markMessageAsRead(messageIds: messageIds, chatTypeEnum: chatTypeEnum);
      // Utils.hideLoading(context);
    } catch (e) {
      logger.i(e.toString());
      Utils.showToast(e.toString());
      // Utils.hideLoading(context);
      status = false;
    }
    return status;
  }

  int _retryCount = 0;
  final int _maxRetries = 5; // Maximum number of consecutive retries before increasing delay
  bool _isReconnecting = false;

  Future<void> _reconnectWithBackoff() async {
    // Never stop trying, but increase delays after max retries
    int delaySeconds;
    if (_retryCount < _maxRetries) {
      delaySeconds = 2 * (_retryCount + 1); // 2, 4, 6, 8, 10 seconds
    } else {
      delaySeconds = 30; // After 5 failures, retry every 30 seconds indefinitely
    }

    logger.i("Retrying connection in $delaySeconds seconds (attempt ${_retryCount + 1})...");
    await Future.delayed(Duration(seconds: delaySeconds));

    _retryCount++;
    await buildHubConnection(); // Try reconnecting (no context needed)
  }

  // Clear all existing listeners to prevent duplicates
  void _clearAllListeners() {
    if (hubConnection != null && _isSubscribed) {
      try {
        hubConnection!.off(SignalrConsts.receiveMessageRequestOffer);
        hubConnection!.off(SignalrConsts.receiveMessageAds);
        hubConnection!.off(SignalrConsts.receiveMessageGeneral);
        _isSubscribed = false;
        logger.i("Cleared all SignalR listeners");
      } catch (e) {
        logger.e("Error clearing listeners: ${e.toString()}");
      }
    }
  }

  Future<void> buildHubConnection({BuildContext? context}) async {
    if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
      if (_isReconnecting) {
        logger.i("Reconnection already in progress");
        return;
      }

      try {
        _isReconnecting = true;

        // Create new hub connection
        hubConnection = await chatRepo.getHubConnection();

        // Start with timeout
        await hubConnection!.start()?.timeout(
          const Duration(seconds: 30),
          onTimeout: () {
            throw Exception("Hub connection timeout");
          },
        );

        // Reset retry count on successful connection
        _retryCount = 0;
        _isReconnecting = false;

        logger.i("Hub Connected Successfully: ${hubConnection!.connectionId}");

        // Clear old listeners before subscribing (prevents duplicates)
        _clearAllListeners();

        // Subscribe to messages (only if context is available for first-time connection)
        // For reconnections, we'll re-subscribe without context
        if (context != null) {
          _subscribeToReceiveRequestOfferMessages(context);
          _subscribeToReceiveAdMessages(context);
          _subscribeToReceiveGeneralMessages(context);
          _isSubscribed = true;
        }

        // Configure handlers
        hubConnection!.onclose((exception) async {
          logger.i("onClose: ${exception.toString()}");
          _isSubscribed = false;
          await _reconnectWithBackoff(); // No context needed
        });

        hubConnection!.onreconnecting((exception) {
          logger.i("onReconnecting: ${exception?.toString()}");
          _isSubscribed = false;
        });

        hubConnection!.onreconnected((connectionId) {
          logger.i("onReconnected: ${connectionId.toString()}");
          // Re-subscribe after automatic reconnect (SignalR's own reconnect, not ours)
          // This is safe because we clear listeners in onreconnecting
          _retryCount = 0; // Reset on successful reconnect
        });
      } catch (e) {
        logger.e("Error during hub connection setup: ${e.toString()}");
        _isReconnecting = false;
        // Retry on failure
        await _reconnectWithBackoff();
      }

      notifyListeners();
    } else {
      logger.i("Hub Already Connected: ${hubConnection!.connectionId.toString()}");
    }
  }

  Future<void> closeHubConnection() async {
    try {
      _clearAllListeners();
      if (hubConnection != null && hubConnection!.state == HubConnectionState.connected) {
        await hubConnection!.stop();
        logger.i("Hub connection closed");
      }
      hubConnection = null;
      _isSubscribed = false;
      _retryCount = 0;
      _isReconnecting = false;
    } catch (e) {
      logger.e("Error closing hub connection: ${e.toString()}");
    }
  }

  Future<bool> onOfferSendForRequest({
    required String receiverId,
    required ChatMessageTypeEnum chatMessageType,
    required String message,
    required int requestId,
    required String offerPrice,
    required bool isDeliveryAvailable,
    required RequestDeliveryOptionEnum offerDeliveryOption,
    required String serviceItemName,
    required String manufacturedByName,
    required String manufacturedOn,
    required List<dynamic> offerImages,
    required BuildContext context,
  }) async {
    // Ensure connection is established
    if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
      logger.i("Hub Not Connected!! Attempting to connect...");
      await buildHubConnection(context: context);

      // Wait a bit for connection to establish
      await Future.delayed(const Duration(milliseconds: 500));

      // Check again after attempt
      if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
        Utils.showToast("Failed to connect. Please try again.");
        return false;
      }
    }

    if (hubConnection!.state == HubConnectionState.connected) {
      final providerId = AppState().getUser.data!.userInfo!.providerId;
      final obj = <String, dynamic>{
        "ReceiverUserID": receiverId,
        "MessageType": chatMessageType.getIdFromChatMessageTypeEnum(),
        "ChatText": message,
        "RequestID": requestId,
        "ReqOfferID": 0,
        "ReqOffer": <String, dynamic>{
          "RequestID": requestId,
          "Price": double.parse(offerPrice),
          "IsDeliveryAvailable": isDeliveryAvailable,
          "OfferDeliveryOption": offerDeliveryOption.getIdRequestDeliveryOptionEnum(),
          "ServiceItem": serviceItemName,
          "ReqOfferImages": offerImages,
          "OfferedItemCreatedByName": manufacturedByName,
          // "OfferedItemCreatedOn": manufacturedOn, // TODO: This should be in String on Server, Right now it is in DateTime
          "ServiceProviderID": providerId,
          "OfferStatus": RequestOfferStatusEnum.offer.getIdFromRequestOfferStatusEnum(),
          "Comment": message,
        },
      };
      logger.i(obj);

      try {
        await hubConnection!.invoke(
          SignalrConsts.sendMessageRequestOffer,
          args: <Object>[obj],
        );
        return true;
      } catch (e) {
        logger.e("error in invoking SendMessageRequestOffer: ${e.toString()}");
        Utils.showToast("Failed to send offer");
        return false;
      }
    }

    return false;
  }

  MessageImageModel convertFileToMessageImageModel({required File file}) {
    List<int> imageBytes = file.readAsBytesSync();
    String image = base64Encode(imageBytes);
    MessageImageModel vehiclePostingImages = MessageImageModel(imageStr: image, id: 0, isFromNetwork: false, reqOfferID: latestOfferId, imagePath: file.path);
    return vehiclePostingImages;
  }

  List<MessageImageModel> getMessagesImageList() {
    List<MessageImageModel> requestImages = [];
    for (var image in pickedImagesForMessage) {
      var value = convertFileToMessageImageModel(file: File(image.filePath!));
      requestImages.add(value);
    }
    return requestImages;
  }

  List<ImageModel> pickedImagesForMessage = [];

  void removeImageFromList(String filePath) {
    int index = pickedImagesForMessage.indexWhere((element) => element.filePath == filePath);
    if (index == -1) {
      return;
    }
    pickedImagesForMessage.removeAt(index);
    notifyListeners();
  }

  void pickMultipleImages() async {
    List<ImageModel> imageModels = [];
    List<File> images = await commonServices.pickMultipleImages();
    for (var element in images) {
      imageModels.add(ImageModel(filePath: element.path, isFromNetwork: false));
    }
    pickedImagesForMessage.addAll(imageModels);
    if (pickedImagesForMessage.length > GlobalConsts.maxFileCount) {
      pickedImagesForMessage = pickedImagesForMessage.sublist(0, GlobalConsts.maxFileCount);
      Utils.showToast(LocaleKeys.maxFileSelection.tr());
    }

    notifyListeners();
  }

  void clearPickedImagesForMessage() {
    pickedImagesForMessage.clear();
    notifyListeners();
  }

  Future<bool> onMessageSendForRequest({
    required String receiverId,
    required ChatMessageTypeEnum chatMessageType,
    required String message,
    required int requestId,
    required BuildContext context,
  }) async {
    if (chatMessageType == ChatMessageTypeEnum.freeText && message.isEmpty) return false;

    // Ensure connection is established
    if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
      logger.i("Hub Not Connected!! Attempting to connect...");
      await buildHubConnection(context: context);

      // Wait a bit for connection to establish
      await Future.delayed(const Duration(milliseconds: 500));

      // Check again after attempt
      if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
        Utils.showToast("Failed to connect. Please try again.");
        return false;
      }
    }

    if (hubConnection!.state == HubConnectionState.connected) {
      final userId = AppState().getUser.data!.userInfo!.userId.toString();
      final name = AppState().getUser.data!.userInfo!.firstName.toString();
      List<Map<String, dynamic>> requestImagesMap = [];
      List<MessageImageModel> messageImages = getMessagesImageList();
      if (messageImages.isNotEmpty && chatMessageType == ChatMessageTypeEnum.image) {
        for (var element in messageImages) {
          requestImagesMap.add(element.toJson());
        }
      }
      final obj = <String, dynamic>{
        "ReceiverUserID": receiverId,
        "SenderUserID": userId,
        "MessageType": chatMessageType.getIdFromChatMessageTypeEnum(),
        "ChatText": chatMessageType == ChatMessageTypeEnum.image ? "${messageImages.length} Image(s)" : message,
        "RequestID": requestId,
        "ReqOfferID": latestOfferId,
      };

      if (chatMessageType == ChatMessageTypeEnum.image) {
        obj.addAll({"ReqOfferImages": requestImagesMap});
      }
      logger.i(obj);

      try {
        await hubConnection!.invoke(
          SignalrConsts.sendMessageRequestOffer,
          args: <Object>[obj],
        );

        ChatMessageModel chatMessageModel = ChatMessageModel(
          messageType: chatMessageType.getIdFromChatMessageTypeEnum(),
          chatText: message,
          isMyMessage: true,
          requestID: requestId,
          senderName: name,
          senderUserID: userId,
          chatMessageTypeEnum: chatMessageType,
          receiverUserID: receiverId,
          messageImages: messageImages,
        );

        if (AppState().currentAppType == AppType.customer) {
          int providerIndex = serviceProviderOffersList.indexWhere((element) => element.providerUserId == receiverId);
          if (providerIndex != -1) {
            serviceProviderOffersList[providerIndex].chatMessages!.add(chatMessageModel);
          }
        } else {
          int providerIndex = context.read<RequestsVM>().myFilteredRequests.indexWhere((element) => (element.customerUserID == receiverId && element.id == requestId));
          log("providerIndex2:$providerIndex");
          if (providerIndex != -1) {
            context.read<RequestsVM>().addChatMessagesInRequestsModel(msg: chatMessageModel, index: providerIndex);
          }
        }
        return true;
      } catch (e) {
        logger.e("error in invoking SendMessage: ${e.toString()}");
        Utils.showToast("Failed to send message");
        return false;
      }
    }
    return false;
  }

  List<ServiceProvidersOffers> serviceProviderOffersList = [];

  Future<void> getOffersFromProvidersByRequest({required int requestId, bool isNeedLoading = true}) async {
    try {
      if (isNeedLoading) {
        setState(ViewState.busy);
      }
      ProviderOffersModel providerOffersModel = await requestRepo.getOffersFromProvidersByRequest(requestId: requestId);
      if (isNeedLoading) {
        setState(ViewState.idle);
      }
      serviceProviderOffersList.clear();
      serviceProviderOffersList = providerOffersModel.serviceProviders ?? [];
      notifyListeners();
    } catch (e) {
      logger.i(e.toString());
      Utils.showToast(e.toString());
      if (isNeedLoading) {
        setState(ViewState.idle);
      }
    }
  }

  Future<void> getRequestsChatMessagesForCustomer({
    required BuildContext context,
    required int providerId,
    required int requestOfferId,
    required int requestId,
    required int providerOfferIndex,
  }) async {
    try {
      int customerId = AppState().getUser.data!.userInfo!.customerId!;
      Utils.showLoading(context);
      List<ChatMessageModel> chatMessages = await chatRepo.getUsersChatMessagesForRequests(providerId: providerId, customerId: customerId, requestOfferId: requestOfferId, requestId: requestId);
      serviceProviderOffersList[providerOfferIndex].chatMessages = chatMessages;
      if (serviceProviderOffersList[providerOfferIndex].chatMessages != null) {
        for (var message in serviceProviderOffersList[providerOfferIndex].chatMessages!) {
          if (message.chatMessageTypeEnum == ChatMessageTypeEnum.offer) {
            updateLatestOfferId(message.reqOfferID ?? 0);
            if (message.reqOffer!.requestOfferStatusEnum == RequestOfferStatusEnum.accepted) {
              context.read<RequestsVM>().updateAcceptedReqOffer(message.reqOffer!);
              context.read<RequestsVM>().updateAcceptedRequestOfferProviderName(serviceProviderOffersList[providerOfferIndex].name ?? "");
            }
            log("latestOfferId: $latestOfferId");
          }
        }
      }
      List<int> unreadMessageIds = [];

      for (var msg in chatMessages) {
        if (!msg.isRead! && !msg.isMyMessage!) {
          unreadMessageIds.add(msg.id!);
        }
      }

      if (unreadMessageIds.isNotEmpty) {
        log("unreadMessageIds: ${unreadMessageIds.toString()}");
        await markMessagesAsRead(context, unreadMessageIds, ChatTypeEnum.requestOffer);
      }
      Utils.hideLoading(context);
      notifyListeners();
    } catch (e) {
      logger.i(e.toString());
      Utils.showToast(e.toString());
      Utils.hideLoading(context);
    }
  }

  Future<void> getRequestsChatMessagesForProvider({
    required BuildContext context,
    required int customerId,
    required int requestOfferId,
    required int requestId,
    required int customerRequestIndex,
  }) async {
    try {
      int providerId = AppState().getUser.data!.userInfo!.providerId!;
      Utils.showLoading(context);
      List<ChatMessageModel> chatMessages = await chatRepo.getUsersChatMessagesForRequests(providerId: providerId, customerId: customerId, requestOfferId: requestOfferId, requestId: requestId);
      await context.read<RequestsVM>().overwriteChatMessagesInRequestsModel(messages: chatMessages, index: customerRequestIndex, context: context);
      List<int> unreadMessageIds = [];
      for (var msg in chatMessages) {
        if (!msg.isRead! && !msg.isMyMessage!) {
          unreadMessageIds.add(msg.id!);
        }
      }
      if (unreadMessageIds.isNotEmpty) {
        await markMessagesAsRead(context, unreadMessageIds, ChatTypeEnum.requestOffer);
      }
      Utils.hideLoading(context);
    } catch (e) {
      logger.i(e.toString());
      Utils.showToast(e.toString());
      Utils.hideLoading(context);
    }
  }

  Future<int> onActionOfferTapped({required BuildContext context, required RequestOfferStatusEnum requestOfferStatusEnum, required int reqOfferId, required String comments}) async {
    Utils.showLoading(context);
    try {
      GenericRespModel genericRespModel = await requestRepo.updateRequestOfferStatus(requestOfferStatusEnum: requestOfferStatusEnum, requestOfferId: reqOfferId, comments: comments);
      Utils.showToast(genericRespModel.message.toString());
      Utils.hideLoading(context);
      return genericRespModel.messageStatus == 1 ? reqOfferId : -1;
    } catch (e) {
      logger.i(e.toString());
      Utils.showToast(e.toString());
      Utils.hideLoading(context);
      return -1;
    }
  }

  Future<bool> onSendMessageForActionOnRequestOffer({
    required String receiverId,
    required ChatMessageTypeEnum chatMessageType,
    required String comments,
    required int requestId,
    required int serviceProviderID,
    required int requestOfferID,
    required String offerPrice,
    required bool isDeliveryAvailable,
    required RequestDeliveryOptionEnum offerDeliveryOption,
    required String serviceItemName,
    required String manufacturedByName,
    required String manufacturedOn,
    required RequestOfferStatusEnum requestOfferStatusEnum,
    required BuildContext context,
  }) async {
    if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
      logger.i("Hub Not Connected!!");

      await buildHubConnection(context: context);
    }
    if (hubConnection!.state == HubConnectionState.connected) {
      var obj = <String, dynamic>{
        "ReceiverUserID": receiverId,
        "MessageType": chatMessageType.getIdFromChatMessageTypeEnum(),
        "ChatText": comments,
        "RequestID": requestId,
        "ReqOfferID": requestOfferID,
        "ReqOffer": <String, dynamic>{
          "ID": requestOfferID,
          "RequestID": requestId,
          "Price": double.parse(offerPrice),
          "ServiceItem": serviceItemName,
          "OfferedItemCreatedByName": manufacturedByName,
          "IsDeliveryAvailable": isDeliveryAvailable,
          "OfferDeliveryOption": offerDeliveryOption.getIdRequestDeliveryOptionEnum(),
          // We have commented this because Backend Team is using their server time for this. It was the time offer created by
          // "OfferedItemCreatedOn": manufacturedOn,
          "ServiceProviderID": serviceProviderID,
          "OfferStatus": requestOfferStatusEnum.getIdFromRequestOfferStatusEnum(),
          "Comment": comments,
        },
      };
      logger.i(obj);

      hubConnection!.invoke(
        SignalrConsts.sendMessageRequestOffer,
        args: <Object>[obj],
      ).catchError((e) {
        logger.i("error in invoking SendMessageRequestOffer: ${e.toString()}");
        Utils.showToast(e.toString());
        return false;
      });
    }
    return true;
  }

  // =================== Ads ======================

  List<ChatMessageModel> currentMessagesForAds = [];

  Future<void> getUsersChatMessagesForAd({required BuildContext context, int? adID, int? adsChatBuyerId, String? userID, String? senderName, required bool isForBuyer}) async {
    try {
      Utils.showLoading(context);
      currentMessagesForAds = await chatRepo.getUsersChatMessagesForAds(userID: userID, adID: adID, isForBuyer: isForBuyer, adsChatBuyerId: adsChatBuyerId);
      Utils.hideLoading(context);

      List<int> unreadMessageIds = [];

      for (var msg in currentMessagesForAds) {
        msg.senderName = senderName ?? "";
        if (!msg.isRead! && !msg.isMyMessage!) {
          unreadMessageIds.add(msg.id!);
        }
      }

      if (unreadMessageIds.isNotEmpty) {
        await markMessagesAsRead(context, unreadMessageIds, ChatTypeEnum.ads);
      }

      notifyListeners();
    } catch (e) {
      logger.i(e.toString());
      Utils.showToast(e.toString());
      Utils.hideLoading(context);
    }
  }

  void _subscribeToReceiveAdMessages(BuildContext context) {
    hubConnection!.on(SignalrConsts.receiveMessageAds, (List<Object?>? arguments) {
      if (arguments == null || arguments.isEmpty) return;
      List<ChatMessageModel> chat = [];
      for (var message in arguments) {
        final chatMessage = ChatMessageModel.fromJson(message as Map<String, dynamic>);
        chat.add(chatMessage);
      }
      onNewMessageReceivedForAds(messages: chat);
      logger.i(arguments);
      // Utils.showToast(arguments.toString());
    });
  }

  Future<void> onNewMessageReceivedForAds({required List<ChatMessageModel> messages}) async {
    for (var msg in messages) {
      currentMessagesForAds.add(msg);
    }
    scrollChatDown();
    notifyListeners();
  }

  Future<bool> onTextMessageSendForAds({
    required String receiverId,
    required ChatMessageTypeEnum chatMessageType,
    required String message,
    required int adId,
    required BuildContext context,
  }) async {
    if (message.isEmpty) return false;

    // Ensure connection is established
    if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
      logger.i("Hub Not Connected!! Attempting to connect...");
      await buildHubConnection(context: context);

      // Wait a bit for connection to establish
      await Future.delayed(const Duration(milliseconds: 500));

      // Check again after attempt
      if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
        Utils.showToast("Failed to connect. Please try again.");
        return false;
      }
    }

    if (hubConnection!.state == HubConnectionState.connected) {
      final userId = AppState().getUser.data!.userInfo!.userId.toString();
      final name = AppState().getUser.data!.userInfo!.firstName.toString();
      final obj = <String, dynamic>{
        "ReceiverUserID": receiverId,
        // "SenderUserID": userId,
        "MessageType": chatMessageType.getIdFromChatMessageTypeEnum(),
        "ChatText": message,
        "AdsID": adId,
      };
      logger.i("$obj");

      try {
        await hubConnection!.invoke(
          SignalrConsts.sendMessageAds,
          args: <Object>[obj],
        );

        ChatMessageModel chatMessageModel = ChatMessageModel(
          messageType: chatMessageType.getIdFromChatMessageTypeEnum(),
          chatText: message,
          isMyMessage: true,
          senderName: name,
          senderUserID: userId,
          chatMessageTypeEnum: ChatMessageTypeEnum.freeText,
          receiverUserID: receiverId,
        );

        currentMessagesForAds.add(chatMessageModel);

        notifyListeners();

        if (AppState().currentAppType == AppType.customer) {
        } else {}
        return true;
      } catch (e) {
        logger.e("error in invoking SendMessage: ${e.toString()}");
        Utils.showToast("Failed to send message");
        return false;
      }
    }
    return false;
  }

  // ========================General ==================

  List<ChatMessageModel> currentMessagesForGeneralChat = [];

  Future<void> getUsersChatMessagesForGeneralChat({required BuildContext context, int? adID, int? adsChatBuyerId, String? userID, String? senderName, required bool isForBuyer}) async {
    try {
      Utils.showLoading(context);
      currentMessagesForGeneralChat = await chatRepo.getUsersChatMessagesForGeneralChat(userID: userID, adID: adID, isForBuyer: isForBuyer, adsChatBuyerId: adsChatBuyerId);
      Utils.hideLoading(context);

      List<int> unreadMessageIds = [];

      for (var msg in currentMessagesForGeneralChat) {
        msg.senderName = senderName ?? "";
        if (!msg.isRead! && !msg.isMyMessage!) {
          unreadMessageIds.add(msg.id!);
        }
      }

      if (unreadMessageIds.isNotEmpty) {
        await markMessagesAsRead(context, unreadMessageIds, ChatTypeEnum.general);
      }
      notifyListeners();
    } catch (e) {
      logger.i(e.toString());
      Utils.showToast(e.toString());
      Utils.hideLoading(context);
    }
  }

  Future<void> onNewMessageReceivedForGeneral({required List<ChatMessageModel> messages}) async {
    for (var msg in messages) {
      currentMessagesForGeneralChat.add(msg); // ✅ FIXED: Use correct list
    }
    scrollChatDown();
    notifyListeners();
  }

  void _subscribeToReceiveGeneralMessages(BuildContext context) {
    hubConnection!.on(SignalrConsts.receiveMessageGeneral, (List<Object?>? arguments) {
      if (arguments == null || arguments.isEmpty) return;
      List<ChatMessageModel> chat = [];
      for (var message in arguments) {
        final chatMessage = ChatMessageModel.fromJson(message as Map<String, dynamic>);
        chat.add(chatMessage);
      }
      onNewMessageReceivedForGeneral(messages: chat);
      logger.i(arguments);
      // Utils.showToast(arguments.toString());
    });
  }

  Future<bool> onTextMessageSendForGeneralChat({
    required String receiverId,
    required ChatMessageTypeEnum chatMessageType,
    required String message,
    required int adId,
    required BuildContext context,
  }) async {
    if (message.isEmpty) return false;

    // Ensure connection is established
    if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
      logger.i("Hub Not Connected!! Attempting to connect...");
      await buildHubConnection(context: context);

      // Wait a bit for connection to establish
      await Future.delayed(const Duration(milliseconds: 500));

      // Check again after attempt
      if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
        Utils.showToast("Failed to connect. Please try again.");
        return false;
      }
    }

    if (hubConnection!.state == HubConnectionState.connected) {
      final userId = AppState().getUser.data!.userInfo!.userId.toString();
      final name = AppState().getUser.data!.userInfo!.firstName.toString();
      final obj = <String, dynamic>{
        "ReceiverUserID": receiverId,
        "MessageType": chatMessageType.getIdFromChatMessageTypeEnum(),
        "ChatText": message,
      };
      logger.i("$obj");

      try {
        await hubConnection!.invoke(
          SignalrConsts.sendMessageGeneral,
          args: <Object>[obj],
        );

        ChatMessageModel chatMessageModel = ChatMessageModel(
          messageType: chatMessageType.getIdFromChatMessageTypeEnum(),
          chatText: message,
          isMyMessage: true,
          senderName: name,
          senderUserID: userId,
          chatMessageTypeEnum: ChatMessageTypeEnum.freeText,
          receiverUserID: receiverId,
        );

        currentMessagesForGeneralChat.add(chatMessageModel);
        notifyListeners();

        if (AppState().currentAppType == AppType.customer) {
        } else {}
        return true;
      } catch (e) {
        logger.e("error in invoking SendMessage: ${e.toString()}");
        Utils.showToast("Failed to send message");
        return false;
      }
    }
    return false;
  }
}