wallet_app/src/stores/modules/webSocketStore.js

// src/stores/websocket.js
import { defineStore } from "pinia";
import { $root as protobuf } from "@/common/proto/proto";
import * as Constant from "@/common/constant/Constant";
import { useWalletStore } from "@/stores/modules/walletStore";
import { getMessageApi, friendRequest, groupList } from "@/api/path/im.api";
import { showDialog } from 'vant';
import { eventBus } from '@/utils/utils';
import { useSystemStore } from "@/stores/modules/systemStore";
import * as MsgType from "@/common/constant/msgType";
import {
  setMessageHook,
  handleMessageHook,
} from "@/views/im/hook/messagesHook";


// 配置常量
const WS_CONFIG = {
  HEARTBEAT_INTERVAL: 30000, // 30秒
  HEARTBEAT_TIMEOUT: 10000, // 10秒
  HEARTBEAT_RETRY_LIMIT: 3,
  RECONNECT_BASE_INTERVAL: 1000,
  RECONNECT_MAX_INTERVAL: 30000,
  RECONNECT_MAX_ATTEMPTS: Infinity,
  RECONNECT_MULTIPLIER: 1.5,
  MESSAGE_QUEUE_MAX_SIZE: 100,
  MESSAGE_QUEUE_FLUSH_INTERVAL: 5000,
};

const messageList = {};//消息缓存

export const useWebSocketStore = defineStore("webSocketStore", {
  state: () => ({
    socket: null,
    peer: null,
    connectionState: "disconnected", // 'connecting', 'connected', 'disconnecting', 'error'
    reconnectAttempts: 0,
    sessionId:null,//当前会话id
    messages: [],
    groupMembersList:{},//群成员列表
    toUserInfo: {},
    unreadMessages: [],
    uuid: null,
    onMessageCallbacks: [],
    messageQueue: [],
    lastActivityTime: 0,
    stats: {
      sentMessages: 0,
      receivedMessages: 0,
      failedMessages: 0,
      reconnects: 0,
    },
    heartbeat: {
      timer: null,
      timeout: null,
      retryCount: 0,
    },
    reconnect: {
      timer: null,
      currentAttempt: 0,
    },
    queueFlushTimer: null,
    loading:false,
    applyfriend:{},//好友申请数据
    unread:false,//判断有无好友申请
    chatDelAuth:{},//控制会话权限
    chatRefresh:0,//刷新会话列表
    indexs:0,// 接收消息计数器
    needRefreshIm:0,//刷新会话
  }),

  persist: {
    key: "toUserInfo",
    storage: localStorage,
    paths: ["toUserInfo", "uuid"],
    serializer: {
      serialize: (state) =>
        JSON.stringify({
          toUserInfo: state.toUserInfo,
          uuid: state.uuid,
        }),
      deserialize: (str) => {
        const data = JSON.parse(str);
        return {
          toUserInfo: data.toUserInfo || {},
          uuid: data.uuid || null,
        };
      },
    },
  },

  getters: {
    isConnected(state) {
      return state.connectionState === "connected";
    },
    hasUnreadMessages(state) {
      return state.unreadMessages.length > 0;
    },
    connectionStatus(state) {
      return state.connectionState;
    },
  },

  actions: {
    // 初始化连接
    connect(userUuid, callback) {
      if (!userUuid) {
        console.error("连接失败: 缺少 userUuid");
        return;
      }

      // 如果正在连接或已连接，则先断开
      if (
        this.connectionState === "connected" ||
        this.connectionState === "connecting"
      ) {
        this.disconnect();
      }

      this.uuid = userUuid;
      this.connectionState = "connecting";
      this.stats.reconnects++;

      try {
        const wsUrl = `${import.meta.env.VITE_PRO_IM_WSS}?user=${userUuid}`;
        this.socket = new WebSocket(wsUrl);

        this.socket.onopen = () => {
          this.connectionState = "connected";
          this.reconnect.currentAttempt = 0;
          this.lastActivityTime = Date.now();
          this.startHeartbeat();
          this.startQueueFlush();

          if (callback && typeof callback === "function") {
            callback();
          }

          console.log("WebSocket 连接成功");
          this.flushMessageQueue(); // 连接成功后立即发送队列中的消息
        };

        this.socket.onmessage = (event) => {
          this.lastActivityTime = Date.now();
          this.handleMessage(event.data);
        };

        this.socket.onclose = () => {
          this.connectionState = "disconnected";
          this.cleanupTimers();

          if (
            this.reconnect.currentAttempt < WS_CONFIG.RECONNECT_MAX_ATTEMPTS
          ) {
            this.scheduleReconnect();
          }
        };

        this.socket.onerror = (error) => {
          this.connectionState = "error";
          console.error("WebSocket 错误:", error);
          this.cleanupTimers();
          this.scheduleReconnect();
        };
      } catch (error) {
        console.error("创建 WebSocket 失败:", error);
        this.connectionState = "error";
        this.scheduleReconnect();
      }
    },

    // 断开连接
    disconnect() {
      this.connectionState = "disconnecting";
      this.cleanupTimers();

      if (this.socket) {
        try {
          this.socket.close();
        } catch (e) {
          console.error("关闭 WebSocket 时出错:", e);
        }
        this.socket = null;
      }

      if (this.peer) {
        this.peer.close();
        this.peer = null;
      }

      this.connectionState = "disconnected";
    },

    // 清理所有定时器
    cleanupTimers() {
      if (this.heartbeat.timer) clearTimeout(this.heartbeat.timer);
      if (this.heartbeat.timeout) clearTimeout(this.heartbeat.timeout);
      if (this.reconnect.timer) clearTimeout(this.reconnect.timer);
      if (this.queueFlushTimer) clearInterval(this.queueFlushTimer);

      this.heartbeat.timer = null;
      this.heartbeat.timeout = null;
      this.reconnect.timer = null;
      this.queueFlushTimer = null;
      this.heartbeat.retryCount = 0;
    },

    // 启动心跳检测
    startHeartbeat() {
      this.cleanupHeartbeat();

      this.heartbeat.timer = setTimeout(() => {
        if (this.isConnected) {
          try {
            const pingMsg = {
              type: "heatbeat",
              content: "ping",
              timestamp: Date.now(),
            };

            this.sendRawMessage(pingMsg);

            // 设置响应超时检测
            this.heartbeat.timeout = setTimeout(() => {
              this.heartbeat.retryCount++;

              if (
                this.heartbeat.retryCount >= WS_CONFIG.HEARTBEAT_RETRY_LIMIT
              ) {
                console.error("心跳响应超时，关闭连接");
                this.disconnect();
              } else {
                console.warn(
                  `心跳无响应，第${this.heartbeat.retryCount}次重试`
                );
                this.startHeartbeat(); // 重新发送心跳
              }
            }, WS_CONFIG.HEARTBEAT_TIMEOUT);
          } catch (error) {
            console.error("心跳发送失败:", error);
            this.scheduleReconnect();
          }
        }
      }, WS_CONFIG.HEARTBEAT_INTERVAL);
    },

    // 清理心跳定时器
    cleanupHeartbeat() {
      if (this.heartbeat.timer) clearTimeout(this.heartbeat.timer);
      if (this.heartbeat.timeout) clearTimeout(this.heartbeat.timeout);
      this.heartbeat.timer = null;
      this.heartbeat.timeout = null;
    },

    // 安排重连
    scheduleReconnect() {
      if (this.reconnect.timer) return;

      this.reconnect.currentAttempt++;

      // 指数退避算法计算重连间隔
      const delay = Math.min(
        WS_CONFIG.RECONNECT_BASE_INTERVAL *
          Math.pow(
            WS_CONFIG.RECONNECT_MULTIPLIER,
            this.reconnect.currentAttempt - 1
          ),
        WS_CONFIG.RECONNECT_MAX_INTERVAL
      );

      console.log(
        `将在 ${delay}ms 后尝试第 ${this.reconnect.currentAttempt} 次重连`
      );

      this.reconnect.timer = setTimeout(() => {
        this.reconnect.timer = null;
        if (!this.isConnected && this.uuid) {
          this.connect(this.uuid);
        }
      }, delay);
    },

    // 发送原始消息（不经过队列）
    sendRawMessage(messageData) {
      if (!this.isConnected) {
        throw new Error("WebSocket 未连接");
      }
      try {
        const MessageType = protobuf.lookupType("protocol.Message");
        const messagePB = MessageType.create(messageData);
        const buffer = MessageType.encode(messagePB).finish();
        this.socket.send(buffer);
        this.stats.sentMessages++;
        return true;
      } catch (error) {
        console.error("消息编码错误:", error);
        this.stats.failedMessages++;
        return false;
      }
    },

    // 发送消息（自动排队)
    sendMessage(messageData) {
      const walletStore = useWalletStore();

      // 构造完整消息
      const fullMessage = {
        to: this.toUserInfo.uuid,
        from: walletStore.account,
        ...messageData,
        fromUsername: walletStore.username,
        avatar: walletStore.avatar,
        timestamp: Date.now(),
      };

      // 如果连接正常，直接发送
      if (this.isConnected) {
        const success = this.sendRawMessage(fullMessage);
        if (success) {
          setMessageHook(fullMessage, this);
          return true;
        }
      }

      // 如果发送失败或未连接，加入队列
      if (this.messageQueue.length < WS_CONFIG.MESSAGE_QUEUE_MAX_SIZE) {
        this.messageQueue.push(fullMessage);
        console.log("消息已加入队列，等待发送");
        return true;
      } else {
        console.error("消息队列已满，丢弃消息");
        return false;
      }
    },

    // 启动队列刷新定时器
    startQueueFlush() {
      if (this.queueFlushTimer) return;

      this.queueFlushTimer = setInterval(() => {
        this.flushMessageQueue();
      }, WS_CONFIG.MESSAGE_QUEUE_FLUSH_INTERVAL);
    },

    // 发送队列中的所有消息
    flushMessageQueue() {
      if (!this.isConnected || this.messageQueue.length === 0) return;

      while (this.messageQueue.length > 0) {
        const message = this.messageQueue.shift();
        try {
          const success = this.sendRawMessage(message);
          if (success) {
            setMessageHook(message, this);
          } else {
            // 发送失败，重新放回队列开头
            this.messageQueue.unshift(message);
            break;
          }
        } catch (error) {
          console.error("发送队列消息失败:", error);
          this.messageQueue.unshift(message);
          break;
        }
      }
    },

    // 处理接收到的消息
    handleMessage(data) {
      const MessageType = protobuf.lookupType("protocol.Message");
      const reader = new FileReader();

      reader.onload = (event) => {
        try {
          const messagePB = MessageType.decode(
            new Uint8Array(event.target.result)
          );
          const message = MessageType.toObject(messagePB, {
            longs: String,
            enums: String,
            bytes: String,
          });

          this.stats.receivedMessages++;
          this.lastActivityTime = Date.now();
          handleMessageHook(message, this);

          // 调用所有回调函数
          this.onMessageCallbacks.forEach((cb) => {
            try {
              cb(message);
            } catch (e) {
              console.error("消息回调错误:", e);
            }
          });

          if (message.type === "heatbeat") {
            this.heartbeat.retryCount = 0; // 重置心跳重试计数
            return;
          }
        } catch (error) {
          console.error("消息解码错误:", error);
          this.stats.failedMessages++;
        }
      };

      reader.readAsArrayBuffer(data);
    },


    // ************功能*************//
    // 添加消息回调
    addOnMessageCallback(cb) {
      if (typeof cb === "function" && !this.onMessageCallbacks.includes(cb)) {
        this.onMessageCallbacks.push(cb);
      }
    },

    // 移除消息回调
    removeOnMessageCallback(cb) {
      this.onMessageCallbacks = this.onMessageCallbacks.filter(
        (item) => item !== cb
      );
    },

    // 处理本地消息
    pushMessage(message, sessionId = null) {
      if(!sessionId){
        sessionId = message.from;
      } 
      if (!messageList[sessionId]) {
        messageList[sessionId] = [];
      }
      messageList[sessionId].push(message);
      // 检测当前消息
      if (this.toUserInfo.uuid === sessionId) { 
        this.messages.push(message);
        this.indexs +=1;
      }
      // 更新会话最新消息
      this.updateSessionNewMessage(message, sessionId)
    },
    modifyMessageId(message, msg, sessionId = null) { 
      if(!sessionId){
        sessionId = message.from;
      }
      if (!messageList[sessionId]) {
        messageList[sessionId] = [];
      }
      messageList[sessionId] = messageList[sessionId].map(item => {
        if (!item.id && item.msgId + '' === msg?.msgId + '') return {...item, id: msg.id, msgId: undefined};
        if (item.id + '' === msg?.msgId + '') return {...item, content: "", url: ""};
        return item;
      });
      // 检测当前消息
      if (this.toUserInfo.uuid === sessionId) { 
        this.messages = this.messages.map(item => {
          if (!item.id && item.msgId + '' === message.msgId + '') return {...item, id: msg.id, msgId: undefined};
          if (item.id + '' === msg?.msgId + '') return {...item, content: "", url: ""};
          return item;
        });
      }
      console.log("修改消息", message, sessionId, messageList, this.messages);
    },
    modifyMessage(message, msgId, sessionId = null) { 
      if(!sessionId){
        sessionId = message.from;
      } 
      if (!messageList[sessionId]) {
        messageList[sessionId] = [];
      }
      messageList[sessionId] = messageList[sessionId].map(item => {
        if (item.id + '' === msgId + '') return {...item, content: "", url: ""};
        return item;
      });
      // 检测当前消息
      if (this.toUserInfo.uuid === sessionId) { 
        this.messages = this.messages.map(item => {
          if (item.id + '' === msgId + '') return {...item, content: "", url: ""};
          return item;
        });
      }
    },
    deleteMessage(message, msgId, sessionId = null) { 
      if(!sessionId){
        sessionId = message.from;
      } 
      if (!messageList[sessionId]) {
        messageList[sessionId] = [];
      }
      console.log("删除消息", message, sessionId, messageList, this.messages);
      messageList[sessionId] = messageList[sessionId].filter(item => {
        if (item.id + '' === msgId + '') return false;
        return true;
      });
      // 检测当前消息
      if (this.toUserInfo.uuid === sessionId) { 
        this.messages = this.messages.filter(item => {
          if (item.id + '' === msgId + '') return false;
          return true;
        });
      }
    },
    // 获取会话消息
    getSessionMessages(sessionId) { 
      if (!messageList[sessionId]) {
        messageList[sessionId] = [];
      }
      return [...messageList[sessionId]];
    },
    // 设置当前会话消息
    setSessionMessages(sessionId, messages) { 
      if (!messageList[sessionId]) {
        messageList[sessionId] = [];
      }
      messageList[sessionId] = Array.isArray(messages)?messages:(typeof messages === 'object'?[messages]:[]);
    },
    // 更换会话
    changeSessionMessage(sessionId) { 
      this.sessionId = sessionId;
      this.messages = this.getSessionMessages(sessionId);
    },

    // 获取历史消息
    async getMessages(params) {
      const router = useRouter();
      const systemStore = useSystemStore();
      // if (this.sessionId){
      //   messageList[this.sessionId] = [...this.messages]
      // }
      // this.messages = [];
      // this.sessionId = this.toUserInfo.uuid //params.uuid;
      // if (messageList[this.sessionId]){
      //   this.messages = messageList[this.sessionId];
      //   return;
      // }
      this.sessionId = this.toUserInfo.uuid;
      this.messages = this.getSessionMessages(this.sessionId);
      if (this.messages.length > 0) {
        return;
      }
      this.loading = true  // 开始加载
      try {
        const res = await getMessageApi({
          messageType: params.messageType,
          uuid: params.uuid,
          friendUsername: params.friendUsername,
        });
        if(res.code == 200){
          // this.messages = (res.data || []).map((item) => {
          //   item.avatar = item.avatar
          //     ? `${import.meta.env.VITE_IM_PATH_FIlE}${item.avatar}`
          //     : item.avatar;
          //   return item;
          // });
          this.setSessionMessages(this.sessionId, (res.data || []));
          this.changeSessionMessage(this.sessionId);
          // return this.messages;
        }else{
          showDialog({
            title: '提示',
            message: res.msg,
            confirmButtonColor:"#4765dd",
          }).then(() => {
            systemStore.needRefreshIm = true;
            router.back();
          });
        }
      } catch (error) {
        console.error("获取消息失败:", error);
        throw error;
      } finally {
        this.loading = false // 结束加载
      }
    },
    // 更新会话列表消息
    updateSessionNewMessage(message, sessionId, msg = null) { 
      const systemStore = useSystemStore();
      let index = systemStore.ImsessionList.findIndex(val=> val.uuid == sessionId);
      // 已读未读
      let unReadNum = 0;
      const ts = message.timestamp || Math.floor(Date.now() / 1000);
      const time = new Date(ts).toISOString().replace("T", " ").split(".")[0];
      // 消息类型映射
      const mapSet = {
        [MsgType.MSG_TYPE.FILE]: '[文件]',
        [MsgType.MSG_TYPE.IMAGE]: '[图片]',
        [MsgType.MSG_TYPE.AUDIO]: '[音频]',
        [MsgType.MSG_TYPE.VIDEO]: '[视频]',
        [MsgType.MSG_TYPE.AUDIO_ONLINE]: '[语音通话]',
        [MsgType.MSG_TYPE.VIDEO_ONLINE]: '[视频通话]',
        // [Constant.CANCELL_AUDIO_ONLINE]:'[通话结束]',
        // [Constant.REJECT_AUDIO_ONLINE]: '[对方拒绝]',
        // [Constant.CANCELL_VIDEO_ONLINE]: '[通话结束]',
        // [Constant.REJECT_VIDEO_ONLINE]: '[对方拒绝]',
      };
      // 检测最新消息
      let lastMsg = message.contentType === MsgType.MSG_TYPE.TEXT || message.contentType === MsgType.MSG_TYPE.NOTICE ? (msg?msg.content : message.content) : (mapSet[message.contentType] || '[语音视频]');
      // 更新
      if(index >= 0){
        systemStore.ImsessionList = systemStore.ImsessionList.map((item, i)=>{
          if(i == index){
            item.message = lastMsg;
            item.lastTime = time;
            item.unReadNum = item.unReadNum + 1;
          }
          return item;
        })
      }
    },

    // 更新缓存里面的会话列表  type:0 发送者   1：接收者
    updateSessionList(payload,type = 0,msg) {
      const walletStore = useWalletStore();
      const message = {...payload};
      console.log('缓存中的列表数据', message, msg)
      const systemStore = useSystemStore();
      const selfUuid = useWalletStore().account; // 当前用户ID
      let sessions = systemStore.ImsessionList ? [...systemStore.ImsessionList] : [];
      const mapSet = {
        [MsgType.MSG_TYPE.FILE]: '[文件]',
        [MsgType.MSG_TYPE.IMAGE]: '[图片]',
        [MsgType.MSG_TYPE.AUDIO]: '[音频]',
        [MsgType.MSG_TYPE.VIDEO]: '[视频]',
        [MsgType.MSG_TYPE.AUDIO_ONLINE]: '[语音通话]',
        [MsgType.MSG_TYPE.VIDEO_ONLINE]: '[视频通话]',
        // [Constant.CANCELL_AUDIO_ONLINE]:'[通话结束]',
        // [Constant.REJECT_AUDIO_ONLINE]: '[对方拒绝]',
        // [Constant.CANCELL_VIDEO_ONLINE]: '[通话结束]',
        // [Constant.REJECT_VIDEO_ONLINE]: '[对方拒绝]',

      };
      // console.log(sessions, sessions.length)
      let lastMsg = message.contentType === MsgType.MSG_TYPE.TEXT || message.contentType === MsgType.MSG_TYPE.NOTICE ? (msg?msg.content : message.content) : (mapSet[message.contentType] || '[语音视频]');
      if ([MsgType.MESSAGE_REVOKE, MsgType.MESSAGE_REVOKE_GROUP].includes(message.messageType)){
        console.log(211111)
        lastMsg = `${message.from == walletStore.account ? '你' : (message.fromUsername || '对方')}撤回了一条消息`
      }

      let index = -1;
      let uuid = type == 0 ? message.to : message.from;
      index = sessions.findIndex(s => (s.uuid || s.id) === uuid);
      if (message.messageType === 2 && type == 0 && index < 0){
        systemStore.needRefreshIm = true;
        return;
      }
      // 过滤无效的消息体
      if (!uuid) {
        return;
      }
      // if (message.messageType === 2) {
      //   // 群聊
      //   index = sessions.findIndex(s => (s.uuid || s.id) === message.to);
      // } else {
        // 单聊
        // if (message.from === selfUuid) {
        //   index = sessions.findIndex(s => (s.uuid || s.id) === message.to);
        // } else {
        //   index = sessions.findIndex(s => (s.uuid || s.id) === message.from);
        // }
      // }
      let unReadNum = 0;
      const ts = message.timestamp || Math.floor(Date.now() / 1000);
      const time = new Date(ts).toISOString().replace("T", " ").split(".")[0];
      if (index > -1) {
        // 如果退群和踢人需要将用户头像移除
        // let avatar = sessions[index].avatar;
        // if (message.messageType == MsgType.EXIT_GROUP || message.messageType == MsgType.REMOVE_GROUP){
        //   avatar = avatar.filter(val=>{
        //     return !message.avatar.includes(val);
        //   })
        // }
        unReadNum = sessions[index].unReadNum + 1;
        // 更新已有会话
        const updated = {
          ...sessions[index],
          message: lastMsg,
          updatedAt: time,
          unReadNum: type == 0 ? 0 : unReadNum
          // avatar
        };
        sessions.splice(index, 1);
        sessions.unshift(updated);
      } else {
        const isSelfSend = message.from === selfUuid;
        const newSession = {
          // uuid: message.messageType === 2 ? message.to : (isSelfSend ? message.to : message.from),
          uuid,
          name: message.toUsername || message.fromUsername || message.to || message.from,
          type: message.messageType == 2?'group':'user',
          message: lastMsg,
          updatedAt: time,
          avatar: message.avatar || '',
          unReadNum: type == 0 ? 0 : unReadNum
        };
        sessions.unshift(newSession);
      }
      systemStore.ImsessionList = [...sessions];
      // if(type != 0){
      //   this.needRefreshIm +=1;
      // }
      this.needRefreshIm += 1;
    },


    // ************ 接收方 方法 ************//

    // 更新会话未读状态
    funUpdateUnread(uuid) {
      const systemStore = useSystemStore();
      let index = systemStore.ImsessionList ? systemStore.ImsessionList.findIndex(s => (s.uuid || s.id) === uuid) : -1;
      if (index > -1) {
        systemStore.ImsessionList[index].unReadNum = 0;
      }
    },
    // 申请好友数据
    funApplyfriend(message) {
      if (message.messageType == MsgType.MESSAGE_APPLY_FRIEND) {
        this.applyfriend[message.from] = 1;
        this.unread = true;
      }
    },
    // 删除会话
    funDeleteSessionMessage(message, msg) {
      if (message.messageType == MsgType.MESSAGE_DELETE_FRIEND || message.messageType == MsgType.DELETE_GROUP || message.messageType == MsgType.REMOVE_GROUP || message.messageType == MsgType.EXIT_GROUP) {
        // let msg;
        // try {
        //   msg = JSON.parse(message.content);
        // } catch (e) { }

        if (msg?.users?.includes(message.to) || message.messageType == MsgType.DELETE_GROUP) {
          this.funDeleteDelAuth(message.from);
          this.deleteSessionChat(message.from);
        }
      }
    },
    // 恢复会话
    funRestoreSessionMessage(message) {
      if (message.messageType == MsgType.CREATE_GROUP || message.messageType == MsgType.JION_GROUP || message.messageType == MsgType.INVITATION_GROUP || message.messageType == MsgType.MESSAGE_PASS_FRIEND) {
        this.chatRefresh += 1;
        if (message.messageType == MsgType.JION_GROUP || message.messageType == MsgType.INVITATION_GROUP || message.messageType == MsgType.MESSAGE_PASS_FRIEND) {
          this.funRestoreDelAuth(message.from);
        }
      }
    },

    // 语音视频通知
    // 群通知
    funGroupNotice(msg){
      this.toUserInfo = {
        ...this.toUserInfo,
        notice: msg && msg.notice?msg.notice: this.toUserInfo.notice,
        nickname: msg && msg.name?msg.name:this.toUserInfo.nickname,
      }
    },
    // 群消息置顶
    funGroupTop(message = null) { 
    },

    // ************ 发送方 方法 ************//
    //  删除好友申请
    deleteFriend(uuid){
      if (this.applyfriend[uuid]) {
        delete this.applyfriend[uuid]
      }
      this.unread = Object.keys(this.applyfriend).length > 0;
    },
    
    // 同意或者拒绝清空applyfriend数据
    funCancelfriend(message){
      if (message.messageType == MsgType.MESSAGE_REJECT_FRIEND || message.messageType == MsgType.MESSAGE_PASS_FRIEND) {
        // if (this.applyfriend[message.from]){
        //  delete this.applyfriend[message.from]
        // }
        // this.unread = Object.keys(this.applyfriend).length > 0;
        this.deleteFriend(message.from);
      }
    },




    // ************ 公用 ************//
    //恢复会话权限
    funRestoreDelAuth(uuid) {
      if (this.chatDelAuth[uuid]) {
        delete this.chatDelAuth[uuid]
      }
    },
    // 禁用会话权限
    funDeleteDelAuth(uuid){
      this.chatDelAuth[uuid] = 1;
    },
    // 初始化好友申请数据
    async funInitfriend(uuid){
      if (Object.keys(this.applyfriend).length > 0){
        this.unread = true;
        return
      };
      const res = await friendRequest({ uuid, status: 1,state:1 });
      if (res.data && res.data.length > 0){
        res.data.forEach(val=>{
          this.applyfriend[val.uuid] = 1
        })
      }
      this.unread = res.data && res.data.length > 0;
    },
    // 删除会话列表
    deleteSessionChat(uuid) {
      const systemStore = useSystemStore();
      let sessions = systemStore.ImsessionList ? [...systemStore.ImsessionList] : [];
      let index = sessions.findIndex(s => (s.uuid || s.id) === uuid);
      if (index > -1) {
        sessions.splice(index, 1);
        systemStore.ImsessionList = sessions;
      }
    },
    // 群成员列表
    async fetchGroupMembers(){
      if (this.toUserInfo.type == 'group'){
        if (this.groupMembersList[this.toUserInfo.uuid]) {
          return this.groupMembersList[this.toUserInfo.uuid]
        }
        try {
          const res = await groupList(this.toUserInfo.uuid);
          this.groupMembersList[this.toUserInfo.uuid] = res.data || [];
          return res.data
        } catch (e) {
          console.error('获取群成员失败', e);
          return []
        }
      }
    }
  },
});