// 消息历史记录管理器 - 微信小程序专用
// 处理消息历史记录的本地缓存、分页加载、存储优化等

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;