wxamp-ymtxUser/pagesA/pages/expertChat/expertChat.js

// pages/consult/consult.js
// import http from '../../../utils/api' // 您的注释代码保留

Page({
  data: {
    // 专家信息
    expertInfo: {
      id: 0,
      name: '',
      title: '',
      expertise: '',
      avatar: '/images/avatars/expert1.png',
      online: false,
      phone: ''
    },
    
    // 用户信息
    userInfo: {
      id: 0,
      name: '用户',
      avatar: '/images/avatars/user.png'
    },
    
    // 消息列表
    messageList: [],
    scrollTop: 0,
    scrollAnimate: false,
    
    // 输入相关
    inputValue: '',
    inputFocus: false,
    inputMode: 'keyboard',
    inputPlaceholder: '请输入消息...',
    
    // 多媒体
    showMediaSheet: false,
    
    // 录音相关
    isRecording: false,
    isCanceling: false,
    recordingTime: 0,
    recordingTip: '松开 发送',
    voiceTip: '按住 说话',
    recordingTimer: null,
    recordManager: null,
    
    // 页面状态
    showDateDivider: true,
    todayDate: '',
    loading: false,
    
    // 滚动相关
    isScrolling: false,
    lastScrollTop: 0,
    
    // 录音相关
    recordStartY: 0,
    
    // 当前专家ID
    currentExpertId: 0,
    
    // 分页相关
    page: 1,
    pageSize: 20,
    hasMore: true,
    
    // 时间显示间隔（分钟）
    timeInterval: 5
  },

  onLoad: function(options) {
    console.log('页面加载，参数:', options);
    
    // 初始化录音管理器
    this.initRecordManager();
    
    // 获取今天日期
    this.setTodayDate();
    
    // 加载用户信息
    this.loadUserInfo();
    
    // 加载专家信息
    if (options.expertId) {
      this.setData({ currentExpertId: options.expertId });
      this.loadExpertInfo(options.expertId);
    } else {
      // 如果没有传expertId，使用默认值
      this.setData({ 
        currentExpertId: 1,
        expertInfo: {
          id: 1,
          name: '张明专家',
          title: '资深畜牧兽医',
          expertise: '牛羊疾病防治',
          avatar: '/images/avatars/expert1.png',
          online: true,
          phone: '13800138000'
        }
      }, () => {
        // 加载聊天记录
        this.loadChatHistory();
      });
    }
    
    // 设置键盘监听
    wx.onKeyboardHeightChange(this.onKeyboardHeightChange.bind(this));
  },

  onUnload: function() {
    console.log('页面卸载');
    
    // 清理定时器
    if (this.data.recordingTimer) {
      clearInterval(this.data.recordingTimer);
    }
    
    // 移除监听器
    wx.offKeyboardHeightChange();
  },

  onShow: function() {
    console.log('页面显示');
  },

  onReady: function() {
    console.log('页面初次渲染完成');
  },

  // 初始化录音管理器
  initRecordManager: function() {
    this.recordManager = wx.getRecorderManager();
    
    this.recordManager.onStart(() => {
      console.log('录音开始');
      this.setData({
        isRecording: true,
        recordingTime: 0,
        recordingTip: '松开 发送'
      });
      
      // 开始计时
      const timer = setInterval(() => {
        const time = this.data.recordingTime + 1;
        this.setData({ recordingTime: time });
      }, 1000);
      
      this.setData({ recordingTimer: timer });
    });
    
    this.recordManager.onStop((res) => {
      console.log('录音停止', res);
      if (this.data.recordingTimer) {
        clearInterval(this.data.recordingTimer);
      }
      
      const { tempFilePath, duration } = res;
      if (tempFilePath && !this.data.isCanceling) {
        this.sendAudioMessage(tempFilePath, Math.floor(duration / 1000));
      }
      
      this.setData({
        isRecording: false,
        isCanceling: false,
        recordingTime: 0
      });
    });
    
    this.recordManager.onError((err) => {
      console.error('录音失败:', err);
      wx.showToast({
        title: '录音失败',
        icon: 'none'
      });
      this.setData({
        isRecording: false,
        isCanceling: false
      });
    });
  },

  // 设置今天日期
  setTodayDate: function() {
    const now = new Date();
    const month = now.getMonth() + 1;
    const date = now.getDate();
    const week = ['日', '一', '二', '三', '四', '五', '六'][now.getDay()];
    this.setData({
      todayDate: `${month}月${date}日 星期${week}`
    });
  },

  // 加载用户信息
  loadUserInfo: function() {
    try {
      // 从本地存储获取用户信息，如果没有则使用默认值
      const userInfo = wx.getStorageSync('userInfo');
      if (userInfo) {
        this.setData({ userInfo });
      } else {
        // 默认用户信息
        const defaultUserInfo = {
          id: 1001,
          name: '养殖户',
          avatar: '/images/avatars/user.png'
        };
        this.setData({ userInfo: defaultUserInfo });
        wx.setStorageSync('userInfo', defaultUserInfo);
      }
    } catch (e) {
      console.error('加载用户信息失败:', e);
      // 使用默认用户信息
      this.setData({
        userInfo: {
          id: 1001,
          name: '养殖户',
          avatar: '/images/avatars/user.png'
        }
      });
    }
  },

  // 加载专家信息 - 使用您的接口调用方式
  loadExpertInfo: function(expertId) {
    console.log('加载专家信息:', expertId);
    wx.showLoading({ title: '加载中...' });
    
    // 使用您的接口调用方式
    // http.getExpertInfo({
    //   data: { expertId: expertId },
    //   success: (res) => {
    //     console.log('专家信息:', res);
        
    //     if (res.code === 0) {
    //       this.setData({
    //         expertInfo: res.data,
    //         loading: false
    //       });
          
    //       // 加载聊天记录
    //       this.loadChatHistory();
    //     } else {
    //       // 如果接口返回失败，使用默认数据
    //       this.loadDefaultExpertInfo(expertId);
    //     }
        
    //     wx.hideLoading();
    //   },
    //   fail: (err) => {
    //     console.error('加载专家信息失败:', err);
    //     wx.hideLoading();
    //     wx.showToast({
    //       title: '加载失败',
    //       icon: 'none'
    //     });
        
    //     // 如果接口调用失败，使用默认数据
    //     this.loadDefaultExpertInfo(expertId);
    //   }
    // });
  },

  // 加载默认专家信息（当接口失败时使用）
  loadDefaultExpertInfo: function(expertId) {
    const experts = [
      {
        id: 1,
        name: '张明专家',
        title: '资深畜牧兽医',
        expertise: '牛羊疾病防治',
        avatar: '/images/avatars/expert1.png',
        online: true,
        phone: '13800138000'
      },
      {
        id: 2,
        name: '李华专家',
        title: '高级畜牧师',
        expertise: '饲料营养',
        avatar: '/images/avatars/expert2.png',
        online: false,
        phone: '13800138001'
      },
      {
        id: 3,
        name: '王强专家',
        title: '兽医专家',
        expertise: '疾病防治',
        avatar: '/images/avatars/expert3.png',
        online: true,
        phone: '13800138002'
      }
    ];
    
    const expertInfo = experts.find(e => e.id == expertId) || experts[0];
    
    this.setData({
      expertInfo,
      loading: false
    });
    
    // 加载聊天记录
    this.loadChatHistory();
  },

  // 加载聊天记录 - 使用您的接口调用方式
  loadChatHistory: function() {
    const { currentExpertId, userInfo, page, pageSize } = this.data;
    
    this.setData({ loading: true });
    
    console.log('加载聊天记录:', { 
      expertId: currentExpertId, 
      userId: userInfo.id,
      page: page,
      pageSize: pageSize
    });
    
    // 使用您的接口调用方式
    // http.getChatHistory({
    //   data: {
    //     expertId: currentExpertId,
    //     userId: userInfo.id,
    //     page: page,
    //     pageSize: pageSize
    //   },
    //   success: (res) => {
    //     console.log('聊天记录:', res);
        
    //     if (res.code === 0) {
    //       const messages = res.data.list || [];
          
    //       if (messages.length > 0) {
    //         // 处理消息时间显示
    //         const processedMessages = this.processMessageTimes(messages);
            
    //         this.setData({
    //           messageList: processedMessages,
    //           loading: false,
    //           hasMore: messages.length >= pageSize
    //         }, () => {
    //           // 滚动到底部
    //           this.scrollToBottom(true);
    //         });
    //       } else {
    //         // 如果没有历史记录，添加一条欢迎消息
    //         this.addWelcomeMessage();
    //       }
    //     } else {
    //       // 如果接口返回失败，使用测试数据
    //       this.loadMockChatHistory();
    //     }
    //   },
    //   fail: (err) => {
    //     console.error('加载聊天记录失败:', err);
    //     this.setData({ loading: false });
        
    //     // 如果接口调用失败，使用测试数据
    //     this.loadMockChatHistory();
    //   }
    // });
  },

  // 加载模拟聊天记录（当接口失败时使用）
  loadMockChatHistory: function() {
    const now = Date.now();
    // 测试数据 - 确保有时间戳
    const mockMessages = [
      {
        id: 'msg-1',
        sender: 'expert',
        type: 'text',
        content: '您好，我是张明专家，有什么可以帮您？',
        timestamp: now - 3600000, // 1小时前
        showTime: true
      },
      {
        id: 'msg-2',
        sender: 'user',
        type: 'text',
        content: '您好，我养的牛最近食欲不振，请问是什么原因？',
        timestamp: now - 1800000, // 30分钟前
        status: 'success',
        showTime: false
      },
      {
        id: 'msg-3',
        sender: 'expert',
        type: 'text',
        content: '可能是饲料问题或环境变化引起的，请描述一下具体情况。',
        timestamp: now - 1200000, // 20分钟前
        showTime: false
      },
      {
        id: 'msg-4',
        sender: 'user',
        type: 'text',
        content: '具体症状是...',
        timestamp: now - 600000, // 10分钟前
        status: 'success',
        showTime: true
      },
      {
        id: 'msg-5',
        sender: 'expert',
        type: 'text',
        content: '明白了，建议您调整饲料配方。',
        timestamp: now - 300000, // 5分钟前
        showTime: false
      }
    ];
    
    // 处理消息时间显示
    const processedMessages = this.processMessageTimes(mockMessages);
    this.setData({
      messageList: processedMessages,
      loading: false,
      hasMore: false
    }, () => {
      // 滚动到底部
      this.scrollToBottom(true);
    });
  },

  // 添加欢迎消息
  addWelcomeMessage: function() {
    const welcomeMessage = {
      id: 'welcome-' + Date.now(),
      sender: 'expert',
      type: 'text',
      content: `您好，我是${this.data.expertInfo.name}，有什么可以帮您？`,
      timestamp: Date.now(),
      showTime: true
    };
    
    this.setData({
      messageList: [welcomeMessage],
      loading: false
    }, () => {
      // 滚动到底部
      this.scrollToBottom(true);
    });
  },

  // 处理消息时间显示 - 优化微信样式
  processMessageTimes: function(messages) {
    if (!messages || messages.length === 0) return [];
    
    // 按时间排序（从早到晚）
    const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp);
    
    let lastShowTime = 0;
    const processedMessages = [];
    
    for (let i = 0; i < sortedMessages.length; i++) {
      const msg = { ...sortedMessages[i] };
      
      // 确保时间戳是有效数字
      if (!msg.timestamp || isNaN(msg.timestamp) || msg.timestamp <= 0) {
        msg.timestamp = Date.now() - (sortedMessages.length - i) * 60000;
      }
      
      // 第一条消息始终显示时间
      if (i === 0) {
        msg.showTime = true;
        lastShowTime = msg.timestamp;
      } else {
        // 计算与上一条显示时间的时间差（分钟）
        const timeDiffMinutes = (msg.timestamp - lastShowTime) / (1000 * 60);
        
        // 超过5分钟显示时间（微信默认5分钟）
        msg.showTime = timeDiffMinutes >= this.data.timeInterval;
        
        if (msg.showTime) {
          lastShowTime = msg.timestamp;
        }
      }
      
      processedMessages.push(msg);
    }
    
    return processedMessages;
  },

  // 返回上一页
  goBack: function() {
    wx.navigateBack();
  },

  // 打电话
  makePhoneCall: function() {
    const phone = this.data.expertInfo.phone;
    if (!phone) {
      wx.showToast({
        title: '暂无联系电话',
        icon: 'none'
      });
      return;
    }
    
    wx.makePhoneCall({
      phoneNumber: phone,
      success: () => {
        console.log('拨打电话成功');
      },
      fail: (err) => {
        console.error('拨打电话失败:', err);
        wx.showToast({
          title: '拨打失败',
          icon: 'none'
        });
      }
    });
  },

  // 输入处理
  onInput: function(e) {
    this.setData({
      inputValue: e.detail.value
    });
  },

  // 输入框获得焦点
  onInputFocus: function() {
    this.setData({
      inputFocus: true
    });
  },

  // 输入框失去焦点
  onInputBlur: function() {
    this.setData({
      inputFocus: false
    });
  },

  // 清除输入
  clearInput: function() {
    this.setData({
      inputValue: '',
      inputFocus: true
    });
  },

  // 发送文本消息 - 使用您的接口调用方式
  sendTextMessage: function() {
    const content = this.data.inputValue.trim();
    if (!content) return;
    
    console.log('发送文本消息:', content);
    
    const newMessage = {
      id: 'msg-' + Date.now(),
      sender: 'user',
      type: 'text',
      content: content,
      timestamp: Date.now(),
      status: 'sending',
      showTime: this.shouldShowTime()
    };
    
    // 添加到消息列表
    this.addMessageToList(newMessage);
    
    // 清空输入框
    this.setData({
      inputValue: '',
      inputFocus: false
    });
    
    // 使用您的接口调用方式发送消息
    // http.sendTextMessage({
    //   data: {
    //     expertId: this.data.currentExpertId,
    //     userId: this.data.userInfo.id,
    //     content: content,
    //     timestamp: Date.now()
    //   },
    //   success: (res) => {
    //     console.log('发送消息成功:', res);
        
    //     if (res.code === 0) {
    //       // 更新消息状态
    //       this.updateMessageStatus(newMessage.id, 'success');
          
    //       // 模拟专家回复
    //       setTimeout(() => {
    //         this.receiveExpertReply();
    //       }, 1000 + Math.random() * 1000);
    //     } else {
    //       // 发送失败
    //       this.updateMessageStatus(newMessage.id, 'error');
    //       wx.showToast({
    //         title: '发送失败',
    //         icon: 'none'
    //       });
    //     }
    //   },
    //   fail: (err) => {
    //     console.error('发送消息失败:', err);
    //     this.updateMessageStatus(newMessage.id, 'error');
    //     wx.showToast({
    //       title: '发送失败',
    //       icon: 'none'
    //     });
    //   }
    // });
  },

  // 判断是否显示时间（基于时间间隔）
  shouldShowTime: function() {
    const { messageList, timeInterval } = this.data;
    if (messageList.length === 0) return true;
    
    const lastMessage = messageList[messageList.length - 1];
    
    // 如果上一条消息显示了时间，检查时间间隔
    if (lastMessage.showTime) {
      const timeDiff = Date.now() - lastMessage.timestamp;
      const timeDiffMinutes = timeDiff / (1000 * 60);
      return timeDiffMinutes >= timeInterval;
    }
    
    return true;
  },

  // 添加消息到列表
  addMessageToList: function(message) {
    const { messageList, timeInterval } = this.data;
    
    // 确保时间戳有效
    if (!message.timestamp || isNaN(message.timestamp) || message.timestamp <= 0) {
      message.timestamp = Date.now();
    }
    
    if (messageList.length > 0) {
      const lastMessage = messageList[messageList.length - 1];
      const timeDiff = message.timestamp - lastMessage.timestamp;
      const timeDiffMinutes = timeDiff / (1000 * 60);
      
      // 根据时间间隔判断是否显示时间
      message.showTime = timeDiffMinutes >= timeInterval;
    } else {
      message.showTime = true;
    }
    
    messageList.push(message);
    
    this.setData({
      messageList
    }, () => {
      // 消息添加后滚动到底部
      this.scrollToBottom();
    });
  },

  // 更新消息状态
  updateMessageStatus: function(messageId, status) {
    const { messageList } = this.data;
    const index = messageList.findIndex(msg => msg.id === messageId);
    
    if (index !== -1) {
      messageList[index].status = status;
      this.setData({ messageList });
    }
  },

  // 接收专家回复 - 使用您的接口调用方式
  receiveExpertReply: function() {
    // 这里可以使用WebSocket或轮询获取新消息
    // 模拟专家回复
    const replies = [
      '收到您的消息，让我分析一下您说的情况。',
      '建议您提供更多细节，比如发病时间、具体症状等。',
      '根据描述，可能是饲料问题引起的，建议调整饲料配方。',
      '可以考虑添加一些维生素补充剂，改善食欲问题。',
      '最好能提供照片，这样我可以更准确地判断情况。'
    ];
    
    const randomReply = replies[Math.floor(Math.random() * replies.length)];
    
    const newMessage = {
      id: 'exp-' + Date.now(),
      sender: 'expert',
      type: 'text',
      content: randomReply,
      timestamp: Date.now(),
      showTime: this.shouldShowTime()
    };
    
    this.addMessageToList(newMessage);
  },

  // 切换输入模式（语音/键盘）
  switchInputMode: function() {
    const currentMode = this.data.inputMode;
    const newMode = currentMode === 'keyboard' ? 'voice' : 'keyboard';
    
    console.log('切换输入模式:', currentMode, '->', newMode);
    
    this.setData({
      inputMode: newMode,
      showMediaSheet: false
    });
    
    if (newMode === 'keyboard') {
      // 切换到键盘模式
      setTimeout(() => {
        this.setData({ 
          inputFocus: true,
          inputPlaceholder: '请输入消息...'
        });
      }, 100);
    } else {
      // 切换到语音模式
      this.setData({
        inputFocus: false,
        inputPlaceholder: '按住说话'
      });
    }
  },

  // 滚动事件处理
  onScroll: function(e) {
    const scrollTop = e.detail.scrollTop;
    this.setData({
      lastScrollTop: scrollTop,
      isScrolling: true
    });
    
    // 延迟重置滚动状态
    clearTimeout(this.scrollTimer);
    this.scrollTimer = setTimeout(() => {
      this.setData({ isScrolling: false });
    }, 200);
    
    // 检查是否需要加载更多
    if (scrollTop <= 100 && !this.data.loading && this.data.hasMore) {
      this.loadMoreMessages();
    }
  },

  // 加载更多消息
  loadMoreMessages: function() {
    if (this.data.loading || !this.data.hasMore) return;
    
    this.setData({ 
      page: this.data.page + 1,
      loading: true 
    });
    
    // 加载更多聊天记录
    this.loadChatHistory();
  },

  // 滚动到底部
  scrollToBottom: function(animate = true) {
    if (this.data.isScrolling) return;
    
    this.setData({
      scrollAnimate: animate
    }, () => {
      // 设置一个足够大的值确保滚动到底部
      this.setData({
        scrollTop: 999999
      });
    });
  },

  // 显示多媒体选择面板
  showMediaActionSheet: function() {
    this.setData({
      showMediaSheet: true,
      inputFocus: false
    });
  },

  // 隐藏多媒体选择面板
  hideMediaActionSheet: function() {
    this.setData({
      showMediaSheet: false
    });
  },

  // 键盘高度变化
  onKeyboardHeightChange: function(res) {
    console.log('键盘高度变化:', res.height);
    if (res.height > 0) {
      // 键盘弹出时隐藏多媒体面板
      this.setData({ showMediaSheet: false });
      
      // 键盘弹出后滚动到底部
      setTimeout(() => {
        this.scrollToBottom();
      }, 300);
    }
  },

  // 选择图片
  chooseImage: function() {
    this.hideMediaActionSheet();
    
    wx.chooseImage({
      count: 9,
      sizeType: ['compressed'],
      sourceType: ['album'],
      success: (res) => {
        console.log('选择图片成功:', res.tempFilePaths);
        this.uploadImages(res.tempFilePaths);
      },
      fail: (err) => {
        console.error('选择图片失败:', err);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },

  // 拍照
  takePhoto: function() {
    this.hideMediaActionSheet();
    
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['camera'],
      success: (res) => {
        console.log('拍照成功:', res.tempFilePaths);
        this.uploadImages(res.tempFilePaths);
      },
      fail: (err) => {
        console.error('拍照失败:', err);
        wx.showToast({
          title: '拍照失败',
          icon: 'none'
        });
      }
    });
  },

  // 选择视频
  chooseVideo: function() {
    this.hideMediaActionSheet();
    
    wx.chooseVideo({
      sourceType: ['album'],
      compressed: true,
      maxDuration: 60,
      success: (res) => {
        console.log('选择视频成功:', res);
        this.uploadVideo(res.tempFilePath, res.thumbTempFilePath);
      },
      fail: (err) => {
        console.error('选择视频失败:', err);
        wx.showToast({
          title: '选择视频失败',
          icon: 'none'
        });
      }
    });
  },

  // 录制语音
  recordAudio: function() {
    this.hideMediaActionSheet();
    this.startVoiceRecord();
  },

  // 选择文件
  chooseFile: function() {
    this.hideMediaActionSheet();
    
    wx.chooseMessageFile({
      count: 1,
      type: 'all',
      success: (res) => {
        console.log('选择文件成功:', res);
        const file = res.tempFiles[0];
        this.uploadFile(file.path, file.name, file.size);
      },
      fail: (err) => {
        console.error('选择文件失败:', err);
        wx.showToast({
          title: '选择文件失败',
          icon: 'none'
        });
      }
    });
  },

  // 上传图片
  uploadImages: function(tempFilePaths) {
    tempFilePaths.forEach((tempFilePath, index) => {
      const fileName = `image_${Date.now()}_${index}.jpg`;
      this.uploadFile(tempFilePath, fileName, 0, 'image');
    });
  },

  // 上传视频
  uploadVideo: function(tempFilePath, thumbPath) {
    const fileName = `video_${Date.now()}.mp4`;
    this.uploadFile(tempFilePath, fileName, 0, 'video', thumbPath);
  },

  // 通用文件上传
  uploadFile: function(tempFilePath, fileName, fileSize = 0, type = 'file', thumbPath = '') {
    console.log('开始上传文件:', { fileName, type, fileSize });
    
    // 获取文件扩展名
    const extension = fileName.split('.').pop().toLowerCase();
    
    // 创建消息
    const messageId = 'file-' + Date.now();
    const message = {
      id: messageId,
      sender: 'user',
      type: type,
      content: tempFilePath,
      thumb: thumbPath,
      fileName: fileName,
      fileSize: fileSize,
      extension: extension,
      timestamp: Date.now(),
      status: 'uploading',
      progress: 0,
      showTime: this.shouldShowTime()
    };
    
    this.addMessageToList(message);
    
    // 模拟上传过程
    this.simulateUpload(messageId, type);
  },

  // 模拟上传过程
  simulateUpload: function(messageId, type) {
    let progress = 0;
    const uploadInterval = setInterval(() => {
      progress += Math.random() * 20 + 10;
      
      if (progress >= 100) {
        progress = 100;
        clearInterval(uploadInterval);
        
        setTimeout(() => {
          this.updateMessageStatus(messageId, 'success');
          
          // 清除进度信息
          const { messageList } = this.data;
          const index = messageList.findIndex(msg => msg.id === messageId);
          if (index !== -1) {
            delete messageList[index].progress;
            this.setData({ messageList });
            
            // 模拟专家回复
            if (type === 'image' || type === 'video') {
              setTimeout(() => {
                this.receiveMediaReply(type);
              }, 800);
            }
          }
        }, 200);
      }
      
      // 更新进度
      const { messageList } = this.data;
      const index = messageList.findIndex(msg => msg.id === messageId);
      if (index !== -1) {
        messageList[index].progress = Math.min(progress, 100);
        this.setData({ messageList });
      }
    }, 100);
  },

  // 接收媒体回复
  receiveMediaReply: function(type) {
    const imageReplies = [
      '照片收到了，牛的状况看起来确实不太理想。',
      '从照片看，饲养环境需要改善一下。',
      '图片清晰，我可以更准确地判断问题了。'
    ];
    
    const videoReplies = [
      '视频看到了，动物的精神状态需要关注。',
      '从视频可以观察到更多细节，这很有帮助。',
      '视频内容很有价值，让我了解了具体情况。'
    ];
    
    const replies = type === 'image' ? imageReplies : videoReplies;
    const randomReply = replies[Math.floor(Math.random() * replies.length)];
    
    const newMessage = {
      id: 'exp-media-' + Date.now(),
      sender: 'expert',
      type: 'text',
      content: randomReply,
      timestamp: Date.now(),
      showTime: this.shouldShowTime()
    };
    
    this.addMessageToList(newMessage);
  },

  // 开始语音录制
  startVoiceRecord: function(e) {
    if (e && e.touches && e.touches[0]) {
      this.setData({
        recordStartY: e.touches[0].clientY
      });
    }
    
    this.recordManager.start({
      duration: 60000,
      sampleRate: 44100,
      numberOfChannels: 1,
      encodeBitRate: 192000,
      format: 'aac'
    });
  },

  // 语音录制触摸移动
  onVoiceTouchMove: function(e) {
    if (!this.data.isRecording) return;
    
    if (e.touches && e.touches[0]) {
      const currentY = e.touches[0].clientY;
      const startY = this.data.recordStartY;
      const deltaY = startY - currentY;
      
      const isCanceling = deltaY > 50;
      
      if (isCanceling !== this.data.isCanceling) {
        this.setData({
          isCanceling: isCanceling,
          recordingTip: isCanceling ? '松开取消' : '松开 发送',
          voiceTip: isCanceling ? '松开取消' : '按住 说话'
        });
      }
    }
  },

  // 结束语音录制
  endVoiceRecord: function() {
    if (this.data.isRecording) {
      this.recordManager.stop();
    }
  },

  // 取消语音录制
  cancelVoiceRecord: function() {
    if (this.data.isRecording) {
      this.setData({
        isCanceling: true
      });
      this.recordManager.stop();
    }
  },

  // 发送语音消息
  sendAudioMessage: function(tempFilePath, duration) {
    console.log('发送语音消息:', { duration });
    
    const message = {
      id: 'audio-' + Date.now(),
      sender: 'user',
      type: 'audio',
      content: tempFilePath,
      duration: duration,
      timestamp: Date.now(),
      status: 'sending',
      showTime: this.shouldShowTime()
    };
    
    this.addMessageToList(message);
    
    // 模拟发送成功
    setTimeout(() => {
      this.updateMessageStatus(message.id, 'success');
      
      // 模拟专家回复
      setTimeout(() => {
        const reply = {
          id: 'exp-audio-' + Date.now(),
          sender: 'expert',
          type: 'text',
          content: '语音收到了，我会仔细听取分析。',
          timestamp: Date.now(),
          showTime: this.shouldShowTime()
        };
        this.addMessageToList(reply);
      }, 1500);
    }, 800);
  },

  // 预览图片
  previewImage: function(e) {
    const url = e.currentTarget.dataset.url;
    wx.previewImage({
      current: url,
      urls: [url],
      fail: (err) => {
        console.error('预览图片失败:', err);
        wx.showToast({
          title: '预览失败',
          icon: 'none'
        });
      }
    });
  },

  // 下载文件
  downloadFile: function(e) {
    const url = e.currentTarget.dataset.url;
    wx.showLoading({ title: '下载中...' });
    
    wx.downloadFile({
      url: url,
      success: (res) => {
        wx.hideLoading();
        wx.showToast({
          title: '下载成功',
          icon: 'success'
        });
        
        // 保存到相册（如果是图片）
        if (url.match(/\.(jpg|jpeg|png|gif)$/i)) {
          wx.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              wx.showToast({
                title: '已保存到相册',
                icon: 'success'
              });
            },
            fail: (err) => {
              console.error('保存到相册失败:', err);
            }
          });
        }
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('下载失败:', err);
        wx.showToast({
          title: '下载失败',
          icon: 'none'
        });
      }
    });
  },

  // 优化：微信样式时间格式化
  formatTime: function(timestamp) {
    if (!timestamp || timestamp <= 0) {
      console.warn('无效的时间戳:', timestamp);
      return '';
    }
    
    const timeNum = Number(timestamp);
    if (isNaN(timeNum)) {
      return '';
    }
    
    const date = new Date(timeNum);
    if (isNaN(date.getTime())) {
      return '';
    }
    
    const now = new Date();
    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
    const yesterday = new Date(today.getTime() - 86400000);
    
    const msgDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
    
    const hours = date.getHours().toString().padStart(2, '0');
    const minutes = date.getMinutes().toString().padStart(2, '0');
    const timeStr = `${hours}:${minutes}`;
    
    // 今天
    if (msgDate.getTime() === today.getTime()) {
      // 小于1分钟显示"刚刚"
      const diffMinutes = (now.getTime() - date.getTime()) / (1000 * 60);
      if (diffMinutes < 1) {
        return '刚刚';
      }
      // 小于1小时显示"X分钟前"
      else if (diffMinutes < 60) {
        return `${Math.floor(diffMinutes)}分钟前`;
      }
      // 今天超过1小时显示时间
      else {
        return timeStr;
      }
    }
    // 昨天
    else if (msgDate.getTime() === yesterday.getTime()) {
      return `昨天 ${timeStr}`;
    }
    // 本周内（7天内）
    else {
      const diffDays = (today.getTime() - msgDate.getTime()) / (1000 * 60 * 60 * 24);
      if (diffDays < 7) {
        const weekDays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
        return `${weekDays[date.getDay()]} ${timeStr}`;
      }
      // 今年内
      else if (date.getFullYear() === now.getFullYear()) {
        const month = date.getMonth() + 1;
        const day = date.getDate();
        return `${month}月${day}日 ${timeStr}`;
      }
      // 更早
      else {
        return `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date.getDate().toString().padStart(2, '0')} ${timeStr}`;
      }
    }
  },

  // 格式化文件大小
  formatFileSize: function(bytes) {
    if (bytes === 0 || !bytes) return '未知大小';
    
    const units = ['B', 'KB', 'MB', 'GB'];
    let size = bytes;
    let unitIndex = 0;
    
    while (size >= 1024 && unitIndex < units.length - 1) {
      size /= 1024;
      unitIndex++;
    }
    
    return size.toFixed(1) + units[unitIndex];
  },

  // 阻止事件冒泡
  stopPropagation: function() {
    // 空函数，仅用于阻止事件冒泡
  }
});