Initial Commit

utils/message-history-manager.js

@@ -0,0 +1,671 @@
+// 消息历史记录管理器 - 微信小程序专用
+// 处理消息历史记录的本地缓存、分页加载、存储优化等
+
+const apiClient = require('./api-client.js');
+
+/**
+ * 消息历史记录管理器
+ * 功能：
+ * 1. 消息历史记录缓存
+ * 2. 分页加载优化
+ * 3. 存储空间管理
+ * 4. 消息去重和排序
+ * 5. 离线消息处理
+ * 6. 数据压缩存储
+ */
+class MessageHistoryManager {
+  constructor() {
+    this.isInitialized = false;
+    
+    // 历史记录配置
+    this.historyConfig = {
+      // 每页消息数量
+      pageSize: 20,
+      
+      // 本地缓存的最大消息数量（每个会话）
+      maxCachedMessages: 500,
+      
+      // 缓存过期时间（毫秒）
+      cacheExpireTime: 24 * 60 * 60 * 1000, // 24小时
+      
+      // 存储压缩阈值（字节）
+      compressionThreshold: 1024,
+      
+      // 自动清理间隔（毫秒）
+      cleanupInterval: 60 * 60 * 1000, // 1小时
+      
+      // 预加载页数
+      preloadPages: 2
+    };
+    
+    // 消息缓存 Map<conversationId, MessageCache>
+    this.messageCache = new Map();
+    
+    // 加载状态 Map<conversationId, LoadingState>
+    this.loadingStates = new Map();
+    
+    // 存储统计
+    this.storageStats = {
+      totalSize: 0,
+      messageCount: 0,
+      conversationCount: 0,
+      lastCleanup: 0
+    };
+    
+    // 清理定时器
+    this.cleanupTimer = null;
+    
+    this.init();
+  }
+
+  // 初始化历史记录管理器
+  async init() {
+    if (this.isInitialized) return;
+    
+    console.log('📚 初始化消息历史记录管理器...');
+    
+    try {
+      // 加载缓存的消息
+      await this.loadCachedMessages();
+      
+      // 计算存储统计
+      this.calculateStorageStats();
+      
+      // 启动定时清理
+      this.startCleanupTimer();
+      
+      this.isInitialized = true;
+      console.log('✅ 消息历史记录管理器初始化完成');
+      
+    } catch (error) {
+      console.error('❌ 消息历史记录管理器初始化失败:', error);
+    }
+  }
+
+  // 获取会话消息历史
+  async getConversationHistory(conversationId, options = {}) {
+    try {
+      console.log('📚 获取会话消息历史:', conversationId);
+      
+      const {
+        page = 1,
+        pageSize = this.historyConfig.pageSize,
+        forceRefresh = false,
+        loadDirection = 'up' // 'up' 向上加载更早的消息, 'down' 向下加载更新的消息
+      } = options;
+      
+      // 获取或创建消息缓存
+      let messageCache = this.getMessageCache(conversationId);
+      if (!messageCache) {
+        messageCache = this.createMessageCache(conversationId);
+      }
+      
+      // 检查是否需要从服务器加载
+      const needServerLoad = forceRefresh || 
+        this.shouldLoadFromServer(messageCache, page, pageSize, loadDirection);
+      
+      if (needServerLoad) {
+        // 从服务器加载消息
+        const serverResult = await this.loadMessagesFromServer(
+          conversationId, 
+          page, 
+          pageSize, 
+          loadDirection,
+          messageCache
+        );
+        
+        if (!serverResult.success) {
+          return serverResult;
+        }
+      }
+      
+      // 从缓存获取消息
+      const messages = this.getMessagesFromCache(messageCache, page, pageSize, loadDirection);
+      
+      return {
+        success: true,
+        data: {
+          messages: messages,
+          page: page,
+          pageSize: pageSize,
+          total: messageCache.totalCount,
+          hasMore: this.hasMoreMessages(messageCache, page, pageSize, loadDirection),
+          cached: !needServerLoad
+        }
+      };
+      
+    } catch (error) {
+      console.error('❌ 获取会话消息历史失败:', error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  // 预加载消息
+  async preloadMessages(conversationId, currentPage = 1) {
+    try {
+      console.log('📚 预加载消息:', conversationId);
+      
+      const preloadPromises = [];
+      
+      // 预加载后续页面
+      for (let i = 1; i <= this.historyConfig.preloadPages; i++) {
+        const nextPage = currentPage + i;
+        preloadPromises.push(
+          this.getConversationHistory(conversationId, { 
+            page: nextPage,
+            loadDirection: 'up'
+          })
+        );
+      }
+      
+      // 并行执行预加载
+      await Promise.allSettled(preloadPromises);
+      console.log('✅ 消息预加载完成');
+      
+    } catch (error) {
+      console.error('❌ 消息预加载失败:', error);
+    }
+  }
+
+  // 添加新消息到缓存
+  addMessageToCache(conversationId, message) {
+    try {
+      let messageCache = this.getMessageCache(conversationId);
+      if (!messageCache) {
+        messageCache = this.createMessageCache(conversationId);
+      }
+      
+      // 检查消息是否已存在
+      const existingIndex = messageCache.messages.findIndex(m => m.id === message.id);
+      if (existingIndex !== -1) {
+        // 更新现有消息
+        messageCache.messages[existingIndex] = message;
+      } else {
+        // 添加新消息（按时间排序）
+        const insertIndex = this.findInsertIndex(messageCache.messages, message);
+        messageCache.messages.splice(insertIndex, 0, message);
+        messageCache.totalCount++;
+      }
+      
+      // 限制缓存大小
+      this.limitCacheSize(messageCache);
+      
+      // 更新缓存时间
+      messageCache.lastUpdated = Date.now();
+      
+      // 保存到本地存储
+      this.saveMessageCache(conversationId, messageCache);
+      
+      console.log('📚 消息已添加到缓存:', message.id);
+      
+    } catch (error) {
+      console.error('❌ 添加消息到缓存失败:', error);
+    }
+  }
+
+  // 更新消息状态
+  updateMessageInCache(conversationId, messageId, updates) {
+    try {
+      const messageCache = this.getMessageCache(conversationId);
+      if (!messageCache) return false;
+      
+      const messageIndex = messageCache.messages.findIndex(m => m.id === messageId);
+      if (messageIndex === -1) return false;
+      
+      // 更新消息
+      messageCache.messages[messageIndex] = {
+        ...messageCache.messages[messageIndex],
+        ...updates
+      };
+      
+      // 更新缓存时间
+      messageCache.lastUpdated = Date.now();
+      
+      // 保存到本地存储
+      this.saveMessageCache(conversationId, messageCache);
+      
+      console.log('📚 消息状态已更新:', messageId);
+      return true;
+      
+    } catch (error) {
+      console.error('❌ 更新消息状态失败:', error);
+      return false;
+    }
+  }
+
+  // 删除消息
+  deleteMessageFromCache(conversationId, messageId) {
+    try {
+      const messageCache = this.getMessageCache(conversationId);
+      if (!messageCache) return false;
+      
+      const messageIndex = messageCache.messages.findIndex(m => m.id === messageId);
+      if (messageIndex === -1) return false;
+      
+      // 删除消息
+      messageCache.messages.splice(messageIndex, 1);
+      messageCache.totalCount--;
+      
+      // 更新缓存时间
+      messageCache.lastUpdated = Date.now();
+      
+      // 保存到本地存储
+      this.saveMessageCache(conversationId, messageCache);
+      
+      console.log('📚 消息已从缓存删除:', messageId);
+      return true;
+      
+    } catch (error) {
+      console.error('❌ 删除消息失败:', error);
+      return false;
+    }
+  }
+
+  // 从服务器加载消息
+  async loadMessagesFromServer(conversationId, page, pageSize, loadDirection, messageCache) {
+    try {
+      // 设置加载状态
+      this.setLoadingState(conversationId, true);
+      
+      // 计算请求参数
+      const requestParams = this.calculateRequestParams(
+        messageCache, 
+        page, 
+        pageSize, 
+        loadDirection
+      );
+      
+      // 调用API
+      const response = await apiClient.request({
+        url: '/api/v1/messages/history',
+        method: 'GET',
+        data: {
+          conversationId: conversationId,
+          ...requestParams
+        }
+      });
+      
+      if (response.success) {
+        // 处理返回的消息
+        const messages = response.data.messages || [];
+        const total = response.data.total || 0;
+        
+        // 更新缓存
+        this.updateCacheWithServerData(messageCache, messages, total, loadDirection);
+        
+        // 保存到本地存储
+        this.saveMessageCache(conversationId, messageCache);
+        
+        console.log(`📚 从服务器加载了 ${messages.length} 条消息`);
+        return { success: true };
+        
+      } else {
+        throw new Error(response.error || '加载消息失败');
+      }
+      
+    } catch (error) {
+      console.error('❌ 从服务器加载消息失败:', error);
+      return { success: false, error: error.message };
+      
+    } finally {
+      this.setLoadingState(conversationId, false);
+    }
+  }
+
+  // 计算请求参数
+  calculateRequestParams(messageCache, page, pageSize, loadDirection) {
+    const params = {
+      pageSize: pageSize
+    };
+    
+    if (loadDirection === 'up') {
+      // 向上加载更早的消息
+      if (messageCache.messages.length > 0) {
+        const oldestMessage = messageCache.messages[messageCache.messages.length - 1];
+        params.beforeTimestamp = oldestMessage.timestamp;
+      }
+    } else {
+      // 向下加载更新的消息
+      if (messageCache.messages.length > 0) {
+        const newestMessage = messageCache.messages[0];
+        params.afterTimestamp = newestMessage.timestamp;
+      }
+    }
+    
+    return params;
+  }
+
+  // 更新缓存数据
+  updateCacheWithServerData(messageCache, newMessages, total, loadDirection) {
+    if (loadDirection === 'up') {
+      // 向上加载：添加到数组末尾（更早的消息）
+      messageCache.messages.push(...newMessages);
+    } else {
+      // 向下加载：添加到数组开头（更新的消息）
+      messageCache.messages.unshift(...newMessages);
+    }
+    
+    // 去重和排序
+    this.deduplicateAndSortMessages(messageCache);
+    
+    // 更新总数
+    messageCache.totalCount = Math.max(total, messageCache.messages.length);
+    
+    // 限制缓存大小
+    this.limitCacheSize(messageCache);
+    
+    // 更新时间戳
+    messageCache.lastUpdated = Date.now();
+  }
+
+  // 消息去重和排序
+  deduplicateAndSortMessages(messageCache) {
+    // 去重
+    const uniqueMessages = new Map();
+    messageCache.messages.forEach(message => {
+      uniqueMessages.set(message.id, message);
+    });
+    
+    // 排序（最新的在前面）
+    messageCache.messages = Array.from(uniqueMessages.values())
+      .sort((a, b) => b.timestamp - a.timestamp);
+  }
+
+  // 查找插入位置
+  findInsertIndex(messages, newMessage) {
+    for (let i = 0; i < messages.length; i++) {
+      if (newMessage.timestamp > messages[i].timestamp) {
+        return i;
+      }
+    }
+    return messages.length;
+  }
+
+  // 限制缓存大小
+  limitCacheSize(messageCache) {
+    if (messageCache.messages.length > this.historyConfig.maxCachedMessages) {
+      // 保留最新的消息
+      const keepCount = Math.floor(this.historyConfig.maxCachedMessages * 0.8);
+      messageCache.messages = messageCache.messages.slice(0, keepCount);
+      console.log(`📚 缓存大小已限制到 ${keepCount} 条消息`);
+    }
+  }
+
+  // 获取消息缓存
+  getMessageCache(conversationId) {
+    return this.messageCache.get(conversationId);
+  }
+
+  // 创建消息缓存
+  createMessageCache(conversationId) {
+    const cache = {
+      conversationId: conversationId,
+      messages: [],
+      totalCount: 0,
+      lastUpdated: Date.now(),
+      loadedPages: new Set(),
+      hasMoreUp: true,
+      hasMoreDown: false
+    };
+    
+    this.messageCache.set(conversationId, cache);
+    return cache;
+  }
+
+  // 从缓存获取消息
+  getMessagesFromCache(messageCache, page, pageSize, loadDirection) {
+    const startIndex = (page - 1) * pageSize;
+    const endIndex = startIndex + pageSize;
+    
+    return messageCache.messages.slice(startIndex, endIndex);
+  }
+
+  // 检查是否有更多消息
+  hasMoreMessages(messageCache, page, pageSize, loadDirection) {
+    if (loadDirection === 'up') {
+      return messageCache.hasMoreUp && 
+        (page * pageSize) < messageCache.totalCount;
+    } else {
+      return messageCache.hasMoreDown;
+    }
+  }
+
+  // 检查是否需要从服务器加载
+  shouldLoadFromServer(messageCache, page, pageSize, loadDirection) {
+    // 如果缓存为空，需要加载
+    if (messageCache.messages.length === 0) {
+      return true;
+    }
+    
+    // 如果请求的页面超出缓存范围，需要加载
+    const startIndex = (page - 1) * pageSize;
+    const endIndex = startIndex + pageSize;
+    
+    if (endIndex > messageCache.messages.length && messageCache.hasMoreUp) {
+      return true;
+    }
+    
+    // 如果缓存过期，需要刷新
+    const cacheAge = Date.now() - messageCache.lastUpdated;
+    if (cacheAge > this.historyConfig.cacheExpireTime) {
+      return true;
+    }
+    
+    return false;
+  }
+
+  // 设置加载状态
+  setLoadingState(conversationId, loading) {
+    this.loadingStates.set(conversationId, {
+      loading: loading,
+      timestamp: Date.now()
+    });
+  }
+
+  // 获取加载状态
+  getLoadingState(conversationId) {
+    const state = this.loadingStates.get(conversationId);
+    return state ? state.loading : false;
+  }
+
+  // 保存消息缓存到本地存储
+  saveMessageCache(conversationId, messageCache) {
+    try {
+      const cacheKey = `message_cache_${conversationId}`;
+      const cacheData = this.compressMessageCache(messageCache);
+      
+      wx.setStorageSync(cacheKey, cacheData);
+      
+    } catch (error) {
+      console.error('❌ 保存消息缓存失败:', error);
+    }
+  }
+
+  // 加载缓存的消息
+  async loadCachedMessages() {
+    try {
+      const storageInfo = wx.getStorageInfoSync();
+      const cacheKeys = storageInfo.keys.filter(key => key.startsWith('message_cache_'));
+      
+      for (const key of cacheKeys) {
+        try {
+          const conversationId = key.replace('message_cache_', '');
+          const cacheData = wx.getStorageSync(key);
+          
+          if (cacheData) {
+            const messageCache = this.decompressMessageCache(cacheData);
+            this.messageCache.set(conversationId, messageCache);
+          }
+          
+        } catch (error) {
+          console.error(`❌ 加载缓存失败 [${key}]:`, error);
+          // 删除损坏的缓存
+          wx.removeStorageSync(key);
+        }
+      }
+      
+      console.log(`📚 加载了 ${this.messageCache.size} 个会话的消息缓存`);
+      
+    } catch (error) {
+      console.error('❌ 加载缓存消息失败:', error);
+    }
+  }
+
+  // 压缩消息缓存
+  compressMessageCache(messageCache) {
+    try {
+      const data = JSON.stringify(messageCache);
+      
+      // 如果数据较大，可以考虑压缩
+      if (data.length > this.historyConfig.compressionThreshold) {
+        // 这里可以实现压缩算法
+        // 目前直接返回原数据
+        return { compressed: false, data: messageCache };
+      }
+      
+      return { compressed: false, data: messageCache };
+      
+    } catch (error) {
+      console.error('❌ 压缩消息缓存失败:', error);
+      return { compressed: false, data: messageCache };
+    }
+  }
+
+  // 解压消息缓存
+  decompressMessageCache(cacheData) {
+    try {
+      if (cacheData.compressed) {
+        // 这里可以实现解压算法
+        return cacheData.data;
+      }
+      
+      return cacheData.data;
+      
+    } catch (error) {
+      console.error('❌ 解压消息缓存失败:', error);
+      return null;
+    }
+  }
+
+  // 计算存储统计
+  calculateStorageStats() {
+    let totalSize = 0;
+    let messageCount = 0;
+    
+    for (const [conversationId, cache] of this.messageCache) {
+      messageCount += cache.messages.length;
+      
+      // 估算缓存大小
+      const cacheSize = JSON.stringify(cache).length;
+      totalSize += cacheSize;
+    }
+    
+    this.storageStats = {
+      totalSize: totalSize,
+      messageCount: messageCount,
+      conversationCount: this.messageCache.size,
+      lastCleanup: Date.now()
+    };
+  }
+
+  // 启动定时清理
+  startCleanupTimer() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+    
+    this.cleanupTimer = setInterval(() => {
+      this.performCleanup();
+    }, this.historyConfig.cleanupInterval);
+  }
+
+  // 执行清理
+  performCleanup() {
+    try {
+      console.log('📚 执行消息缓存清理...');
+      
+      const now = Date.now();
+      let cleanedCount = 0;
+      
+      for (const [conversationId, cache] of this.messageCache) {
+        // 清理过期缓存
+        const cacheAge = now - cache.lastUpdated;
+        if (cacheAge > this.historyConfig.cacheExpireTime * 2) {
+          this.messageCache.delete(conversationId);
+          wx.removeStorageSync(`message_cache_${conversationId}`);
+          cleanedCount++;
+        }
+      }
+      
+      // 更新统计
+      this.calculateStorageStats();
+      
+      console.log(`📚 清理完成，删除了 ${cleanedCount} 个过期缓存`);
+      
+    } catch (error) {
+      console.error('❌ 消息缓存清理失败:', error);
+    }
+  }
+
+  // 清除会话缓存
+  clearConversationCache(conversationId) {
+    this.messageCache.delete(conversationId);
+    wx.removeStorageSync(`message_cache_${conversationId}`);
+    console.log('📚 已清除会话缓存:', conversationId);
+  }
+
+  // 清除所有缓存
+  clearAllCache() {
+    for (const conversationId of this.messageCache.keys()) {
+      wx.removeStorageSync(`message_cache_${conversationId}`);
+    }
+    this.messageCache.clear();
+    this.calculateStorageStats();
+    console.log('📚 已清除所有消息缓存');
+  }
+
+  // 获取存储统计
+  getStorageStats() {
+    this.calculateStorageStats();
+    return { ...this.storageStats };
+  }
+
+  // 获取会话统计
+  getConversationStats(conversationId) {
+    const cache = this.getMessageCache(conversationId);
+    if (!cache) {
+      return null;
+    }
+    
+    return {
+      messageCount: cache.messages.length,
+      totalCount: cache.totalCount,
+      lastUpdated: cache.lastUpdated,
+      cacheAge: Date.now() - cache.lastUpdated,
+      hasMoreUp: cache.hasMoreUp,
+      hasMoreDown: cache.hasMoreDown
+    };
+  }
+
+  // 重置管理器
+  reset() {
+    this.clearAllCache();
+    this.loadingStates.clear();
+    
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  // 销毁管理器
+  destroy() {
+    this.reset();
+    this.isInitialized = false;
+  }
+}
+
+// 创建全局实例
+const messageHistoryManager = new MessageHistoryManager();
+
+module.exports = messageHistoryManager;