yogaApp/store/chatStore.js

import { MESSAGE_TYPE, MESSAGE_STATUS } from "@/common/enums.js"
// import localForage from 'localforage'
import {myCache} from "../utils/utils";

// 全局缓存变量（用于延迟渲染）
let cacheChats = []

// =================== Vuex 模块 ===================
const chatModule = {
	namespaced: true,

	state: () => ({
		activeChat: null,
		privateMsgMaxId: 0,
		groupMsgMaxId: 0,
		loadingPrivateMsg: false,
		loadingGroupMsg: false,
		chats: []               // 实际渲染的会话列表（仅前 N 个）
	}),

	getters: {
		// 是否正在加载离线消息
		isLoading: (state) => () => {
			return state.loadingPrivateMsg || state.loadingGroupMsg
		},

		// 返回当前应显示的会话列表（加载中返回缓存列表，否则返回真实列表）
		curChats: (state, getters) => () => {
			if (cacheChats && getters.isLoading()) {
				return cacheChats
			}
			return state.chats
		},

		// 查找会话索引
		findChatIdx: (state, getters) => (chat) => {
			const chats = getters.curChats()
			for (let idx in chats) {
				if (chats[idx].type === chat.type && chats[idx].targetId === chat.targetId) {
					return parseInt(idx)
				}
			}

			return -1
		},

		// 查找会话对象
		findChat: (state, getters) => (chat) => {
			const idx = getters.findChatIdx(chat)
			return idx >= 0 ? getters.curChats()[idx] : null
		},

		findChatByFriend: (state, getters) => (fid) => {
			const chats = getters.curChats()
			return chats.find(c => c.type === 'PRIVATE' && c.targetId === fid)
		},

		findChatByGroup: (state, getters) => (gid) => {
			const chats = getters.curChats()
			return chats.find(c => c.type === 'GROUP' && c.targetId === gid)
		},

		// 在指定 chat 中查找消息
		findMessage: (state, getters) => (chat, msgInfo) => {
			if (!chat) return null
			for (let idx in chat.messages) {
				const m = chat.messages[idx]
				if (msgInfo.id && m.id === msgInfo.id) return m
				if (msgInfo.tmpId && m.tmpId && m.tmpId === msgInfo.tmpId) return m
			}
			return null
		}
	},

	mutations: {
		// ---------- 基础 mutations ----------
		SET_CHATS(state, chats) {
			state.chats = chats
		},
		SET_PRIVATE_MSG_MAX_ID(state, id) {
			state.privateMsgMaxId = id
		},
		SET_GROUP_MSG_MAX_ID(state, id) {
			state.groupMsgMaxId = id
		},
		SET_LOADING_PRIVATE(state, loading) {
			state.loadingPrivateMsg = loading
		},
		SET_LOADING_GROUP(state, loading) {
			state.loadingGroupMsg = loading
		},
		SET_ACTIVE_CHAT(state, chat) {
			state.activeChat = chat
		},

		// ---------- 会话操作 ----------
		ADD_CHAT(state, newChat) {
			// 插入到列表头部
			state.chats.unshift(newChat)
		},

		REMOVE_CHAT(state, idx) {
			if (idx >= 0 && idx < state.chats.length) {
				state.chats.splice(idx, 1)
			}
		},

		MOVE_CHAT_TO_TOP(state, idx) {
			if (idx > 0 && idx < state.chats.length) {
				const chat = state.chats[idx]
				state.chats.splice(idx, 1)
				state.chats.unshift(chat)
				chat.lastSendTime = new Date().getTime()
				chat.stored = false
			}
		},

		UPDATE_CHAT(state, { idx, chat }) {
			if (idx >= 0 && idx < state.chats.length) {
				state.chats[idx] = chat
			}
		},

		RESET_UNREAD_COUNT(state, { type, targetId }) {
			for (let c of state.chats) {
				if (c.type === type && c.targetId === targetId) {
					c.unreadCount = 0
					c.atMe = false
					c.atAll = false
					c.stored = false
					break
				}
			}
		},

		// ---------- 消息操作 ----------
		UPDATE_MESSAGE(state, { chatIdx, msgInfo }) {
			const chat = state.chats[chatIdx]
			if (!chat) return
			const msg = chat.messages.find(m => (m.id && m.id === msgInfo.id) || (m.tmpId && m.tmpId === msgInfo.tmpId))
			if (msg) {
				Object.assign(msg, msgInfo)
				chat.stored = false
			}
		},

		DELETE_MESSAGE(state, { chatIdx, msgInfo }) {
			const chat = state.chats[chatIdx]
			if (!chat) return
			const idx = chat.messages.findIndex(m => (m.id && m.id === msgInfo.id) || (m.tmpId && m.tmpId === msgInfo.tmpId))
			if (idx !== -1) {
				chat.messages.splice(idx, 1)
				chat.stored = false
			}
		},


		// 更新会话的头像/名称
		UPDATE_CHAT_INFO(state, { targetId, type, headImage, showName }) {
			for (let c of state.chats) {
				if (c.type === type && c.targetId === targetId) {
					if (headImage) c.headImage = headImage
					if (showName) c.showName = showName
					c.stored = false
					break
				}
			}
		},
		// 更新 chat 的基本信息（lastContent, lastSendTime, sendNickName, unreadCount, atMe, atAll）
		UPDATE_CHAT_SUMMARY(state, { idx, lastContent, lastSendTime, sendNickName, unreadCount, atMe, atAll }) {
			const chat = state.chats[idx];
			if (!chat) return;
			if (lastContent !== undefined) chat.lastContent = lastContent;
			if (lastSendTime !== undefined) chat.lastSendTime = lastSendTime;
			if (sendNickName !== undefined) chat.sendNickName = sendNickName;
			if (unreadCount !== undefined) chat.unreadCount = unreadCount;
			if (atMe !== undefined) chat.atMe = atMe;
			if (atAll !== undefined) chat.atAll = atAll;
			chat.stored = false;
		},

		// 插入时间戳消息
		PUSH_TIME_TIP(state, { idx, sendTime }) {
			const chat = state.chats[idx];
			if (!chat) return;
			chat.messages.push({ sendTime, type: MESSAGE_TYPE.TIP_TIME });
			chat.lastTimeTip = sendTime;
			chat.stored = false;
		},

		// 插入消息（支持指定位置）
		INSERT_MESSAGE(state, { idx, msg, insertPos }) {
			const chat = state.chats[idx];
			if (!chat) return;
			if (insertPos === undefined || insertPos === chat.messages.length) {
				chat.messages.push(msg);
			} else {
				chat.messages.splice(insertPos, 0, msg);
			}
			chat.stored = false;
		},

		// 更新已有的消息（合并属性）
		UPDATE_EXISTING_MESSAGE(state, { idx, msgInfo }) {
			const chat = state.chats[idx];
			if (!chat) return;
			const msg = chat.messages.find(m => (m.id && m.id === msgInfo.id) || (m.tmpId && m.tmpId === msgInfo.tmpId));
			if (msg) Object.assign(msg, msgInfo);
			chat.stored = false;
		},

		// 删除消息
		DELETE_MESSAGE_BY_ID(state, { idx, msgInfo }) {
			const chat = state.chats[idx];
			if (!chat) return;
			const pos = chat.messages.findIndex(m => (m.id && m.id === msgInfo.id) || (m.tmpId && m.tmpId === msgInfo.tmpId));
			if (pos !== -1) {
				chat.messages.splice(pos, 1);
				chat.stored = false;
			}
		},

		// 撤回消息
		RECALL_MESSAGE(state, { idx, targetId, recallContent, sendTime, selfSend }) {
			const chat = state.chats[idx];
			if (!chat) return;
			for (let m of chat.messages) {
				if (m.id === targetId) {
					m.status = MESSAGE_STATUS.RECALL;
					m.content = recallContent;
					m.type = MESSAGE_TYPE.TIP_TEXT;
					// 更新会话最后一条（如果撤回的是最后一条）
					if (chat.messages[chat.messages.length - 1] === m) {
						chat.lastContent = recallContent;
						chat.lastSendTime = sendTime;
						chat.sendNickName = '';
					}
					break;
				}
			}
			// 处理引用消息
			for (let m of chat.messages) {
				if (m.quoteMessage && m.quoteMessage.id === targetId) {
					m.quoteMessage.content = "引用内容已撤回";
					m.quoteMessage.status = MESSAGE_STATUS.RECALL;
					m.quoteMessage.type = MESSAGE_TYPE.TIP_TEXT;
				}
			}
			chat.stored = false;
		},

		// 更新会话头像和名称
		UPDATE_CHAT_AVATAR_NAME(state, { type, targetId, headImage, showName }) {
			for (let chat of state.chats) {
				if (chat.type === type && chat.targetId === targetId) {
					if (headImage !== undefined) chat.headImage = headImage;
					if (showName !== undefined) chat.showName = showName;
					chat.stored = false;
					break;
				}
			}
		},
		// 一次性替换所有会话（用于 refreshChats）
		REPLACE_CHATS(state, chats) {
			state.chats = chats;
			// 清空缓存（全局变量）
			cacheChats = null;
		},

		// 更新单个 chat 的 hotMinIdx 和 stored 等
		UPDATE_CHAT_META(state, { idx, hotMinIdx, stored }) {
			const chat = state.chats[idx];
			if (!chat) return;
			if (hotMinIdx !== undefined) chat.hotMinIdx = hotMinIdx;
			if (stored !== undefined) chat.stored = stored;
		},
		CLEAR_UNREAD_COUNT(state, idx) {
			const chats = state.chats;   // 或者通过 getter 获取当前列表
			if (idx >= 0 && idx < chats.length) {
				const chat = chats[idx];
				if (chat) {
					chat.unreadCount = 0;
					chat.atMe = false;
					chat.atAll = false;
					chat.stored = false;      // 标记需持久化
				}
			}
		}
	},

	actions: {
		// ========== 初始化 ==========
		initChats({ commit, state }, chatsData) {
			cacheChats = []
			commit('SET_CHATS', [])
			commit('SET_PRIVATE_MSG_MAX_ID', chatsData.privateMsgMaxId || 0)
			commit('SET_GROUP_MSG_MAX_ID', chatsData.groupMsgMaxId || 0)

			const allChats = chatsData.chats || []
			for (let chat of allChats) {
				chat.stored = false
				// 深拷贝存入缓存，用于延迟渲染
				cacheChats.push(JSON.parse(JSON.stringify(chat)))
				// 仅渲染前 15 个会话（可调）
				if (state.chats.length < 15) {
					// 直接 push 新对象，避免引用缓存
					state.chats.push({ ...chat })
				}
			}
			// 防止图片一直处在加载中状态
			cacheChats.forEach((chat) => {
				chat.messages.forEach((msg) => {
					if (msg.loadStatus == "loading") {
						msg.loadStatus = "fail"
					}
				})
			})
		},

		// ========== 打开会话 ==========
		openChat({ state, getters, commit, dispatch }, chatInfo) {
			// 加载中直接返回（原逻辑）
			// if (getters.isLoading()) return
			const chats = getters.curChats()
			let existingIdx = -1
			for (let idx in chats) {
				if (chats[idx].type === chatInfo.type && chats[idx].targetId === chatInfo.targetId) {
					existingIdx = parseInt(idx)
					break
				}
			}

			if (existingIdx !== -1) {
				// 已存在 → 移到顶部
				dispatch('moveTop', existingIdx)
			} else {
				// 新建会话
				const newChat = {
					targetId: chatInfo.targetId,
					type: chatInfo.type,
					showName: chatInfo.showName,
					headImage: chatInfo.headImage,
					lastContent: "",
					lastSendTime: new Date().getTime(),
					unreadCount: 0,
					hotMinIdx: 0,
					messages: [],
					atMe: false,
					atAll: false,
					stored: false,
					delete: false
				}
				commit('ADD_CHAT', newChat)
				// 原逻辑未立即保存，等待后续消息触发保存
				dispatch('saveToStorage', { withColdMessage: false })
			}
		},

		activeChat({ commit, getters }, idx) {
			const chats = getters.curChats();   // 使用 getter 获取当前列表（支持加载状态）
			if (idx >= 0 && idx < chats.length) {
				commit('CLEAR_UNREAD_COUNT', idx);
			}
		},
		// ========== 移动会话到顶部 ==========
		moveTop({ state, getters, commit, dispatch }, idx) {
			if (getters.isLoading()) return
			if (idx > 0 && idx < state.chats.length) {
				commit('MOVE_CHAT_TO_TOP', idx)

				// 移动后保存（原逻辑在 moveTop 最后调用了 saveToStorage）
				dispatch('saveToStorage', { withColdMessage: false })
			}
		},
		removeChat({ state, getters, commit, dispatch }, idx) {

			const chats = getters.curChats()
			chats[idx].delete = true
			chats[idx].stored = false
			dispatch('saveToStorage', { withColdMessage: false })
		},
		resetUnreadCount({ state, getters, dispatch }, chatInfo) {
			const chats = getters.curChats()
			for (let idx in chats) {
				if (chats[idx].type === chatInfo.type && chats[idx].targetId === chatInfo.targetId) {
					chats[idx].unreadCount = 0
					chats[idx].atMe = false
					chats[idx].atAll = false
					chats[idx].stored = false
					dispatch('saveToStorage', { withColdMessage: false })
					break
				}
			}
		},
		readedMessage({ state, getters, dispatch }, pos) {
			const chat = getters.findChatByFriend(pos.friendId)
			if (!chat) return
			chat.messages.forEach((m) => {
				let status=Number(m.status)
				if (m.id && m.selfSend && status < MESSAGE_STATUS.RECALL) {
					// pos.maxId为空表示整个会话已读
					if (!pos.maxId || m.id <= pos.maxId) {
						m.status = MESSAGE_STATUS.READED
						chat.stored = false
					}
				}
			})
			dispatch('saveToStorage', { withColdMessage: false })
		},


		/**
		 * 删除私聊会话
		 * @param {Object} context - Vuex action 上下文
		 * @param {Number|String} userId - 对方用户ID
		 */
		removePrivateChat({ getters, dispatch }, userId) {
			const chats = getters.curChats()
			for (let idx in chats) {
				if (chats[idx].type === 'PRIVATE' && chats[idx].targetId === userId) {
					// 将索引转为数字（因为 for...in 返回字符串）
					dispatch('removeChat', parseInt(idx))
					break // 一个用户只有一个私聊会话，找到后退出
				}
			}
		},

		/**
		 * 删除群聊会话
		 * @param {Object} context - Vuex action 上下文
		 * @param {Number|String} groupId - 群ID
		 */
		removeGroupChat({ getters, dispatch }, groupId) {
			const chats = getters.curChats()
			for (let idx in chats) {
				if (chats[idx].type === 'GROUP' && chats[idx].targetId === groupId) {
					dispatch('removeChat', parseInt(idx))
					break
				}
			}
		},
		insertMessage({ state, getters, commit, dispatch, rootState }, { msgInfo, chatInfo }) {
			const type = chatInfo.type;
			// 更新最大消息 ID
			if (msgInfo.id && type === "PRIVATE" && msgInfo.id > state.privateMsgMaxId) {
				commit('SET_PRIVATE_MSG_MAX_ID', msgInfo.id);
			}
			if (msgInfo.id && type === "GROUP" && msgInfo.id > state.groupMsgMaxId) {
				commit('SET_GROUP_MSG_MAX_ID', msgInfo.id);
			}

			// 查找会话
			const idx = getters.findChatIdx(chatInfo);
			if (idx === -1) return;
			const chat = state.chats[idx]; // 直接引用

			// 检查是否已存在该消息（重发或更新）
			const existingMsg = getters.findMessage(chat, msgInfo);
			if (existingMsg) {
				commit('UPDATE_EXISTING_MESSAGE', { idx, msgInfo });
				dispatch('saveToStorage', { withColdMessage: false });
				return;
			}

			let msgInfoType=Number(msgInfo.type)
			let msgInfoStatus=Number(msgInfo.status)
			// 准备要更新的字段
			let lastContent = chat.lastContent;
			if (msgInfoType === MESSAGE_TYPE.IMAGE) lastContent = "[图片]";
			else if (msgInfoType === MESSAGE_TYPE.FILE) lastContent = "[文件]";
			else if (msgInfoType === MESSAGE_TYPE.AUDIO) lastContent = "[语音]";
			else if (msgInfoType === MESSAGE_TYPE.ACT_RT_VOICE) lastContent = "[语音通话]";
			else if (msgInfoType === MESSAGE_TYPE.ACT_RT_VIDEO) lastContent = "[视频通话]";
			else if (msgInfoType === MESSAGE_TYPE.TEXT || msgInfoType === MESSAGE_TYPE.RECALL || msgInfoType === MESSAGE_TYPE.TIP_TEXT) {
				lastContent = msgInfo.content;
			}

			// 更新最后消息摘要
			let unreadCount = chat.unreadCount || 0;
			let atMe = chat.atMe || false;
			let atAll = chat.atAll || false;

			// 未读计数
			if (!msgInfo.selfSend && msgInfoStatus !== MESSAGE_STATUS.READED &&
				msgInfoStatus !== MESSAGE_STATUS.RECALL && msgInfoType !== MESSAGE_TYPE.TIP_TEXT) {
				unreadCount++;
			}

			// @ 处理
			if (!msgInfo.selfSend && chat.type === "GROUP" && msgInfo.atUserIds && msgInfoStatus !== MESSAGE_STATUS.READED) {
				const userInfo = rootState.user?.userInfo;
				if (userInfo) {
					if (msgInfo.atUserIds.includes(userInfo.id)) atMe = true;
					if (msgInfo.atUserIds.includes(-1)) atAll = true;
				}
			}

			// 更新会话摘要（通过 mutation）
			commit('UPDATE_CHAT_SUMMARY', {
				idx,
				lastContent,
				lastSendTime: msgInfo.sendTime,
				sendNickName: msgInfo.sendNickName,
				unreadCount,
				atMe,
				atAll
			});

			// 时间戳提示（间隔10分钟）
			if (!chat.lastTimeTip || (chat.lastTimeTip < msgInfo.sendTime - 600 * 1000)) {
				commit('PUSH_TIME_TIP', { idx, sendTime: msgInfo.sendTime });
			}

			// 计算插入位置（防止乱序）
			let insertPos = chat.messages.length;
			if (msgInfo.id && msgInfo.id > 0) {
				for (let i = 0; i < chat.messages.length; i++) {
					const m = chat.messages[i];
					if (m.id && msgInfo.id < m.id) {
						insertPos = i;
						console.log(`消息乱序修正: ${chat.messages.length} -> ${insertPos}`);
						break;
					}
				}
			}

			// 插入消息
			commit('INSERT_MESSAGE', { idx, msg: msgInfo, insertPos });

			// 标记已存储为 false（已在 mutation 中完成）
			// 保存到本地
			dispatch('saveToStorage', { withColdMessage: false });
		},

		// ========== 更新消息 ==========
		updateMessage({ getters, commit, dispatch }, { msgInfo, chatInfo }) {
			const idx = getters.findChatIdx(chatInfo);
			if (idx === -1) return;
			commit('UPDATE_EXISTING_MESSAGE', { idx, msgInfo });
			dispatch('saveToStorage', { withColdMessage: false });
		},

		// ========== 删除消息 ==========
		deleteMessage({ getters, commit, dispatch }, { msgInfo, chatInfo }) {
			const idx = getters.findChatIdx(chatInfo);
			if (idx === -1) return;
			const chat = getters.findChat(chatInfo);
			// 找到消息位置，判断是否为冷消息（仅用于记录，不影响存储）
			let isCold = false;
			for (let i = 0; i < chat.messages.length; i++) {
				const m = chat.messages[i];
				if ((m.id && m.id === msgInfo.id) || (m.tmpId && m.tmpId === msgInfo.tmpId)) {
					isCold = i < chat.hotMinIdx;
					break;
				}
			}
			commit('DELETE_MESSAGE_BY_ID', { idx, msgInfo });
			dispatch('saveToStorage', { withColdMessage: isCold });
		},

		// ========== 撤回消息 ==========
		recallMessage({ getters, commit, dispatch, rootState }, { msgInfo, chatInfo }) {
			const idx = getters.findChatIdx(chatInfo);
			if (idx === -1) return;
			const chat = getters.findChat(chatInfo);
			const targetId = msgInfo.content; // 被撤回的消息ID
			// 构建撤回提示内容
			const name = msgInfo.selfSend ? '你' : (chat.type === 'PRIVATE' ? '对方' : msgInfo.sendNickName);
			const recallContent = name + "撤回了一条消息";
			// 判断是否为冷消息
			let isCold = false;
			for (let i = 0; i < chat.messages.length; i++) {
				if (chat.messages[i].id === targetId) {
					isCold = i < chat.hotMinIdx;
					break;
				}
			}
			commit('RECALL_MESSAGE', { idx, targetId, recallContent, sendTime: msgInfo.sendTime, selfSend: msgInfo.selfSend });
			// 更新未读计数（如果撤回的是对方消息且未读）
			if (!msgInfo.selfSend && Number(msgInfo.status) !== MESSAGE_STATUS.READED) {
				// 需要在 mutation 中增加未读计数？但原逻辑是 chat.unreadCount++，我们可以在 mutation 中处理
				// 但为了复用，我们在 action 中手动增加（通过 UPDATE_CHAT_SUMMARY）
				const chatRef = state.chats[idx];
				if (chatRef) {
					commit('UPDATE_CHAT_SUMMARY', { idx, unreadCount: (chatRef.unreadCount || 0) + 1 });
				}
			}
			dispatch('saveToStorage', { withColdMessage: isCold });
		},

		// ========== 更新会话信息（好友） ==========
		updateChatFromFriend({ commit, dispatch }, friend) {
			commit('UPDATE_CHAT_AVATAR_NAME', {
				type: 'PRIVATE',
				targetId: friend.id,
				headImage: friend.headImage,
				showName: friend.nickName
			});
			// 存储（会影响多个会话，但只更新了头像名称，可延迟保存）
			dispatch('saveToStorage', { withColdMessage: false });
		},

		// ========== 更新会话信息（用户自身） ==========
		updateChatFromUser({ commit, dispatch }, user) {
			commit('UPDATE_CHAT_AVATAR_NAME', {
				type: 'PRIVATE',
				targetId: user.id,
				headImage: user.headImageThumb,
				showName: user.nickName
			});
			dispatch('saveToStorage', { withColdMessage: false });
		},

		// ========== 更新会话信息（群组） ==========
		updateChatFromGroup({ commit, dispatch }, group) {
			commit('UPDATE_CHAT_AVATAR_NAME', {
				type: 'GROUP',
				targetId: group.id,
				headImage: group.headImageThumb,
				showName: group.name
			});
			dispatch('saveToStorage', { withColdMessage: false });
		},


		setLoadingPrivateMsg({ commit, dispatch, getters }, loading) {

			commit('SET_LOADING_PRIVATE', loading);
			if (!getters.isLoading()) {   // 使用 context.getters（模块内局部 getters）
				dispatch('refreshChats');
			}
		},

		setLoadingGroupMsg({ commit, dispatch, getters }, loading) {
			commit('SET_LOADING_GROUP', loading);
			if (!getters.isLoading()) {   // 同上
				dispatch('refreshChats');
			}
		},

		// ========== 刷新会话列表（将缓存数据一次性渲染） ==========
		refreshChats({ commit, dispatch }) {
			if (!cacheChats) return;
			// 排序（按最后消息时间倒序）
			cacheChats.sort((a, b) => b.lastSendTime - a.lastSendTime);

			// 非 App 端容量限制：每个会话最多保留1000条消息
			// #ifndef APP-PLUS
			cacheChats.forEach(chat => {
				if (chat.messages.length > 1000) {
					chat.messages = chat.messages.slice(-1000);
				}
			});
			// #endif

			// 记录热数据索引（所有消息都视为热数据）
			cacheChats.forEach(chat => chat.hotMinIdx = chat.messages.length);

			// 一次性替换 state.chats
			commit('REPLACE_CHATS', cacheChats);
			// 清空缓存变量（已在 mutation 中处理）
			// 持久化
			dispatch('saveToStorage', { withColdMessage: true });
		},



		// ========== 保存到本地 ==========
		saveToStorage({ state, getters, rootState }, { withColdMessage = false } = {}) {

			if (getters.isLoading()) return
			const userId = myCache('user').userid;
			if (!userId) return
			const key = `chats-app-${userId}`
			const chatKeys = []
			// 按会话为单位存储，
			state.chats.forEach(chat => {
				// 只存储有改动的会话
				const chatKey = `${key}-${chat.type}-${chat.targetId}`
				if (!chat.stored) {

					if (chat.delete) {
						uni.removeStorageSync(chatKey);
					} else {
						// 存储冷数据
						if (withColdMessage) {
							const coldChat = { ...chat, messages: chat.messages.slice(0, chat.hotMinIdx) }
							uni.setStorageSync(chatKey, coldChat)
						}
						// 存储热消息
						const hotKey = chatKey + '-hot'
						const hotChat = { ...chat, messages: chat.messages.slice(chat.hotMinIdx) }
						uni.setStorageSync(hotKey, hotChat);
					}
					chat.stored = true
				}
				if (!chat.delete) {
					chatKeys.push(chatKey)
				}
			})
			const chatsData = {
				privateMsgMaxId: state.privateMsgMaxId,
				groupMsgMaxId: state.groupMsgMaxId,
				chatKeys
			}
			uni.setStorageSync(key, chatsData)
			// 移除已删除的会话
			state.chats = state.chats.filter(c => !c.delete)
		},

		// ========== 加载离线消息 ==========
		loadChat({ commit, dispatch, rootState }) {

			return new Promise((resolve, reject) => {
				var userId = myCache('user').userid;
				if (!userId) return resolve()
				const key = `chats-app-${userId}`
				const chatsData = uni.getStorageSync(`chats-app-${userId}`);
				if (chatsData) {
					if (chatsData.chatKeys) {
						chatsData.chats = [];
						chatsData.chatKeys.forEach(key => {
							const coldChat = uni.getStorageSync(key);
							const hotChat = uni.getStorageSync(key + '-hot');
							if (!coldChat && !hotChat) {
								return;
							}
							// 合并冷热消息
							const chat = Object.assign({}, coldChat, hotChat);
							if (hotChat && coldChat) {
								chat.messages = coldChat.messages.concat(hotChat.messages);
							}
							chatsData.chats.push(chat);
						});
					}
					// 调用 initChats action 初始化数据
					dispatch('initChats', chatsData);
				}
				resolve();


			})
		},
		clear(state){

		},
		// ... 其他 actions 类似迁移
	}
}

export default chatModule