// 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

  // Store ViewModels to avoid context dependency
  RequestsVM? _requestsVM;
  AdVM? _adVM;

  // Track if a message is currently being sent (prevents duplicate sends)
  bool isSendingMessage = false;

  // Method to inject ViewModels (called once from Dashboard)
  void setViewModels({required RequestsVM requestsVM, required AdVM adVM}) {
    _requestsVM = requestsVM;
    _adVM = adVM;
    logger.i("ViewModels injected into ChatVM");
  }

  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;

  // Track currently active chat
  int? currentAdsId;
  String? currentReceiverId;
  int? currentRequestId;

  // Update current chat context
  void setCurrentChatContext({int? adsId, String? receiverId, int? requestId}) {
    currentAdsId = adsId;
    currentReceiverId = receiverId;
    currentRequestId = requestId;
  }

  // Clear current chat context
  void clearCurrentChatContext() {
    currentAdsId = null;
    currentReceiverId = null;
    currentRequestId = null;
  }

  // Check if currently on a specific ad chat
  bool isOnAdChat(int adsId, String receiverId) {
    return isUserOnChatScreen && currentAdsId == adsId && currentReceiverId == receiverId;
  }

  // Check if currently on a specific request chat
  bool isOnRequestChat(int requestId, String receiverId) {
    return isUserOnChatScreen && currentRequestId == requestId && currentReceiverId == receiverId;
  }

  final ScrollController scrollController = ScrollController();

  void scrollChatDown() {
    if (!isUserOnChatScreen) {
      return;
    }
    if (scrollController.hasClients) {
      // Check if attached to exactly one scroll view
      try {
        if (scrollController.positions.length == 1) {
          scrollController.animateTo(
            scrollController.position.maxScrollExtent + 200, // for the text field
            duration: const Duration(seconds: 1),
            curve: Curves.fastOutSlowIn,
          );
        } else {
          log("⚠️ ScrollController attached to ${scrollController.positions.length} scroll views, skipping scroll");
        }
      } catch (e) {
        log("Error scrolling chat: $e");
      }
    }
  }

  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) {
          // Check if message already exists to prevent duplicates
          bool messageExists = false;

          if (currentMessage.id != null) {
            // For messages with ID, use ID for duplicate detection
            messageExists = serviceProviderOffersList[providerIndex].chatMessages!.any((msg) => msg.id == currentMessage.id);
          } else {
            // For messages without ID (locally created), use content-based duplicate detection
            // Check if same sender, same text, same reqOfferID within short time window
            messageExists = serviceProviderOffersList[providerIndex].chatMessages!.any((msg) {
              return msg.senderUserID == currentMessage.senderUserID &&
                  msg.chatText == currentMessage.chatText &&
                  msg.reqOfferID == currentMessage.reqOfferID &&
                  msg.messageType == currentMessage.messageType;
            });
          }

          if (messageExists) {
            log("Message already exists (id: ${currentMessage.id}), skipping duplicate");
            continue;
          }

          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) {
          // Check if message already exists to prevent duplicates
          bool messageExists = false;

          if (currentMessage.id != null) {
            // For messages with ID, use ID for duplicate detection
            messageExists = requestsVM.myFilteredRequests[requestIndex].chatMessages.any((msg) => msg.id == currentMessage.id);
          } else {
            // For messages without ID (locally created), use content-based duplicate detection
            // Check if same sender, same text, same reqOfferID within short time window
            messageExists = requestsVM.myFilteredRequests[requestIndex].chatMessages.any((msg) {
              return msg.senderUserID == currentMessage.senderUserID &&
                  msg.chatText == currentMessage.chatText &&
                  msg.reqOfferID == currentMessage.reqOfferID &&
                  msg.messageType == currentMessage.messageType;
            });
          }

          if (messageExists) {
            log("Message already exists (id: ${currentMessage.id}), skipping duplicate");
            continue;
          }

          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;
              }
            }

            // If this offer was accepted, update the request status to inProgress
            // This ensures all other offers show "offerNoLongerAvailable" on provider side
            if (currentMessage.reqOffer!.requestOfferStatusEnum == RequestOfferStatusEnum.accepted) {
              log("Offer accepted, updating request status to inProgress");
              requestsVM.myFilteredRequests[requestIndex].requestStatus = RequestStatusEnum.inProgress;
            }
          }
          requestsVM.addChatMessagesInRequestsModel(msg: currentMessage, index: requestIndex);
          scrollChatDown();
        }
      }
    }
    notifyListeners();
  }

  void _subscribeToReceiveRequestOfferMessages() {
    if (_requestsVM == null) {
      logger.e("RequestsVM not set! Cannot subscribe to request offer messages.");
      return;
    }

    // Clear existing listener first to prevent duplicates
    try {
      hubConnection!.off(SignalrConsts.receiveMessageRequestOffer);
    } catch (e) {
      // Ignore if no listener exists
    }

    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: _requestsVM!);
      // Utils.showToast(arguments.toString());
    });
    logger.i("Subscribed to RequestOffer messages");
  }

  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);
        hubConnection!.off(SignalrConsts.requestOfferReadUpdate);
        _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 (no context needed anymore!)
        if (_requestsVM != null && _adVM != null) {
          _subscribeToReceiveRequestOfferMessages();
          _subscribeToReceiveAdMessages();
          _subscribeToReceiveGeneralMessages();
          _subscribeToRequestOfferReadUpdate();
          _isSubscribed = true;
          log("✅ All SignalR listeners subscribed | Hub: ${hubConnection!.connectionId}");
          log("📍 Events: ReceiveMessageRequestOffer, ReceiveMessageAds, ReceiveMessageGeneral, RequestOfferReadUpdate");
        } else {
          logger.w("ViewModels not injected yet. Listeners will be subscribed after injection.");
        }

        // 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) async {
          logger.i("onReconnected: ${connectionId.toString()}");
          _retryCount = 0; // Reset on successful reconnect

          // ✅ CRITICAL FIX: Re-subscribe listeners after automatic reconnect
          if (_requestsVM != null && _adVM != null) {
            _clearAllListeners();
            _subscribeToReceiveRequestOfferMessages();
            _subscribeToReceiveAdMessages();
            _subscribeToReceiveGeneralMessages();
            _subscribeToRequestOfferReadUpdate();
            _isSubscribed = true;
            logger.i("✅ Listeners re-subscribed after automatic reconnection");
          } else {
            logger.e("❌ Cannot re-subscribe: ViewModels not set!");
          }
        });
      } 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;

    // ✅ Prevent duplicate sends
    if (isSendingMessage) {
      logger.w("Message already being sent, ignoring duplicate tap");
      return false;
    }

    isSendingMessage = true;
    notifyListeners();

    try {
      // 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.");
          isSendingMessage = false;
          notifyListeners();
          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 {
            // ✅ Use stored RequestsVM instead of context.read
            if (_requestsVM != null) {
              int providerIndex = _requestsVM!.myFilteredRequests.indexWhere((element) => (element.customerUserID == receiverId && element.id == requestId));
              log("providerIndex2:$providerIndex");
              if (providerIndex != -1) {
                _requestsVM!.addChatMessagesInRequestsModel(msg: chatMessageModel, index: providerIndex);
              }
            }
          }

          isSendingMessage = false;
          notifyListeners();
          return true;
        } catch (e) {
          logger.e("error in invoking SendMessage: ${e.toString()}");
          Utils.showToast("Failed to send message");
          isSendingMessage = false;
          notifyListeners();
          return false;
        }
      }

      isSendingMessage = false;
      notifyListeners();
      return false;
    } catch (e) {
      logger.e("Unexpected error in onMessageSendForRequest: ${e.toString()}");
      isSendingMessage = false;
      notifyListeners();
      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() {
    if (_adVM == null) {
      logger.e("AdVM not set! Cannot subscribe to ad messages.");
      return;
    }

    // Clear existing listener first to prevent duplicates
    try {
      hubConnection!.off(SignalrConsts.receiveMessageAds);
    } catch (e) {
      // Ignore if no listener exists
    }

    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());
    });
    logger.i("Subscribed to Ads messages");
  }

  Future<void> onNewMessageReceivedForAds({required List<ChatMessageModel> messages}) async {
    final myUserId = AppState().getUser.data?.userInfo?.userId?.toString();
    
    for (var msg in messages) {
      // Skip if this is my own message echoed back from server
      if (myUserId != null && msg.senderUserID == myUserId) {
        log("Skipping own message echoed from server (sender: ${msg.senderUserID})");
        continue;
      }
      
      // Check if message already exists to prevent duplicates
      bool messageExists = false;

      if (msg.id != null) {
        // For messages with ID, use ID for duplicate detection
        messageExists = currentMessagesForAds.any((existingMsg) => existingMsg.id == msg.id);
      } else {
        // For messages without ID (locally created), use content-based duplicate detection
        messageExists = currentMessagesForAds.any((existingMsg) {
          return existingMsg.senderUserID == msg.senderUserID && existingMsg.chatText == msg.chatText && existingMsg.messageType == msg.messageType;
        });
      }

      if (messageExists) {
        log("Message already exists in ads chat (id: ${msg.id}), skipping duplicate");
        continue;
      }
      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;

    // ✅ Prevent duplicate sends
    if (isSendingMessage) {
      logger.w("Message already being sent, ignoring duplicate tap");
      return false;
    }

    isSendingMessage = true;
    notifyListeners();

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

        // Wait longer for connection to fully establish and register with server
        await Future.delayed(const Duration(milliseconds: 1500));

        // Check again after attempt
        if (hubConnection == null || hubConnection!.state != HubConnectionState.connected) {
          Utils.showToast("Failed to connect. Please try again.");
          isSendingMessage = false;
          notifyListeners();
          return false;
        }
        
        // Extra verification: ensure connection ID is available
        if (hubConnection!.connectionId == null) {
          logger.w("Connection ID not yet available, waiting a bit more...");
          await Future.delayed(const Duration(milliseconds: 500));
        }
        
        logger.i("Connection ready! ConnectionId: ${hubConnection!.connectionId}");
      }

      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,  // ✅ Send SenderUserID so backend knows who sent it
          "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 {}

          isSendingMessage = false;
          notifyListeners();
          return true;
        } catch (e) {
          logger.e("error in invoking SendMessage: ${e.toString()}");
          Utils.showToast("Failed to send message");
          isSendingMessage = false;
          notifyListeners();
          return false;
        }
      }

      isSendingMessage = false;
      notifyListeners();
      return false;
    } catch (e) {
      logger.e("Unexpected error in onTextMessageSendForAds: ${e.toString()}");
      isSendingMessage = false;
      notifyListeners();
      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) {
      // Check if message already exists to prevent duplicates
      bool messageExists = false;

      if (msg.id != null) {
        // For messages with ID, use ID for duplicate detection
        messageExists = currentMessagesForGeneralChat.any((existingMsg) => existingMsg.id == msg.id);
      } else {
        // For messages without ID (locally created), use content-based duplicate detection
        messageExists = currentMessagesForGeneralChat.any((existingMsg) {
          return existingMsg.senderUserID == msg.senderUserID && existingMsg.chatText == msg.chatText && existingMsg.messageType == msg.messageType;
        });
      }

      if (messageExists) {
        log("Message already exists in general chat (id: ${msg.id}), skipping duplicate");
        continue;
      }
      currentMessagesForGeneralChat.add(msg); // ✅ FIXED: Use correct list
    }
    scrollChatDown();
    notifyListeners();
  }

  void _subscribeToReceiveGeneralMessages() {
    // Clear existing listener first to prevent duplicates
    try {
      hubConnection!.off(SignalrConsts.receiveMessageGeneral);
    } catch (e) {
      // Ignore if no listener exists
    }

    // General messages don't need specific VM, just storing messages
    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());
    });
    logger.i("Subscribed to General messages");
  }

  void _subscribeToRequestOfferReadUpdate() {
    if (_requestsVM == null) {
      logger.e("RequestsVM not set! Cannot subscribe to request offer read updates.");
      return;
    }

    // Clear existing listener first to prevent duplicates
    try {
      hubConnection!.off(SignalrConsts.requestOfferReadUpdate);
    } catch (e) {
      // Ignore if no listener exists
    }

    hubConnection!.on(SignalrConsts.requestOfferReadUpdate, (List<Object?>? arguments) {
      log("🔔 RequestOfferReadUpdate EVENT TRIGGERED! Args: $arguments");

      if (arguments == null || arguments.isEmpty) {
        log("⚠️ RequestOfferReadUpdate: Arguments are null or empty");
        return;
      }

      try {
        final data = arguments[0] as Map<String, dynamic>;
        log("✅ Parsed RequestOfferReadUpdate data: reqOfferChatID=${data['reqOfferChatID']}, isRead=${data['isRead']}");
        _handleRequestOfferReadUpdate(data);
      } catch (e) {
        log("❌ Error parsing RequestOfferReadUpdate: ${e.toString()}");
      }
    });

    log("✅ Subscribed to RequestOfferReadUpdate");
  }

  void _handleRequestOfferReadUpdate(Map<String, dynamic> data) async {
    try {
      final int? messageId = data['reqOfferChatID'];
      final int? reqOfferID = data['reqOfferID'];
      final bool? isRead = data['isRead'];
      final String? readOn = data['readOn'];

      if (messageId == null) {
        log("❌ RequestOfferReadUpdate: reqOfferChatID is null");
        return;
      }

      log("📨 Processing read update: msgID=$messageId, offerID=$reqOfferID, isRead=$isRead");

      // For Provider App: Reload messages from API to get updated read status and IDs
      if (AppState().currentAppType == AppType.provider && _requestsVM != null) {
        // Check if viewing the chat currently (currentSelectedRequest is set)
        if (_requestsVM!.currentSelectedRequest != null) {
          log("🔄 Reloading messages for currentSelectedRequest (ID: ${_requestsVM!.currentSelectedRequest!.id})");

          await _reloadRequestMessages(
            requestId: _requestsVM!.currentSelectedRequest!.id,
            requestOfferId: 0, // Provider side always uses 0 (sees all offers for request)
            customerId: _requestsVM!.currentSelectedRequest!.customerId ?? 0,
          );

          log("✅ Reloaded messages for currentSelectedRequest - read status updated");
        } else {
          // No current chat open, optionally reload all requests
          // (In most cases, we only care about updating the currently visible chat)
          log("ℹ️ Read update received but no active chat open, skipping reload");
        }
      }

      // For Customer App: Not needed (customer is the one marking as read)
      if (AppState().currentAppType == AppType.customer) {
        log("RequestOfferReadUpdate on customer side (ignored)");
      }
    } catch (e) {
      log("❌ Error in _handleRequestOfferReadUpdate: ${e.toString()}");
    }
  }

  /// Helper method to reload request messages from API without showing loading dialog
  Future<void> _reloadRequestMessages({
    required int requestId,
    required int requestOfferId,
    required int customerId,
  }) async {
    try {
      int providerId = AppState().getUser.data!.userInfo!.providerId!;

      log("🔄 Fetching messages from API: requestId=$requestId, requestOfferId=$requestOfferId");

      List<ChatMessageModel> chatMessages = await chatRepo.getUsersChatMessagesForRequests(
        providerId: providerId,
        customerId: customerId,
        requestOfferId: requestOfferId,
        requestId: requestId,
      );

      // Find the request in myFilteredRequests and update its messages
      int requestIndex = _requestsVM!.myFilteredRequests.indexWhere((req) => req.id == requestId);
      if (requestIndex != -1) {
        _requestsVM!.myFilteredRequests[requestIndex].chatMessages = chatMessages;

        // Also update currentSelectedRequest if it's the same request
        if (_requestsVM!.currentSelectedRequest != null && _requestsVM!.currentSelectedRequest!.id == requestId) {
          _requestsVM!.currentSelectedRequest!.chatMessages = chatMessages;
        }

        log("✅ Updated ${chatMessages.length} messages for request $requestId");
        notifyListeners();
      } else {
        log("⚠️ Request $requestId not found in myFilteredRequests");
      }
    } catch (e) {
      log("❌ Error reloading messages: ${e.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;

    // ✅ Prevent duplicate sends
    if (isSendingMessage) {
      logger.w("Message already being sent, ignoring duplicate tap");
      return false;
    }

    isSendingMessage = true;
    notifyListeners();

    try {
      // 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.");
          isSendingMessage = false;
          notifyListeners();
          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 {}

          isSendingMessage = false;
          notifyListeners();
          return true;
        } catch (e) {
          logger.e("error in invoking SendMessage: ${e.toString()}");
          Utils.showToast("Failed to send message");
          isSendingMessage = false;
          notifyListeners();
          return false;
        }
      }

      isSendingMessage = false;
      notifyListeners();
      return false;
    } catch (e) {
      logger.e("Unexpected error in onTextMessageSendForGeneralChat: ${e.toString()}");
      isSendingMessage = false;
      notifyListeners();
      return false;
    }
  }
}