const app = getApp();
import { formatDate } from '../../static/lib/utils';
import { sendGroupMessage } from '../../utils/message-sender';
import { getLocalImUserId } from '../../utils/im-user.js';
import { resolveAvatarUrl, getDefaultAvatarUrl, resolveAvatarFromStorage } from '../../utils/avatar.js';
import { getZhuangtaiText, isPairGroupId, normalizeGroupMessage, recordConversationOpen } from '../../utils/group-chat.js';
import request from '../../utils/request';
import {
  fetchHistoryMessages,
  getOldestHistoryTimestamp,
  mergeHistoryMessages,
  waitChatImReady,
} from '../../utils/chat-history.js';

Page({
  data: {
    groupId: '',
    groupName: '',
    groupAvatar: '',
    orderId: '',
    isCross: 0,
    orderZhuangtai: null,
    orderZhuangtaiText: '',
    orderJieshao: '',
    orderJine: '',
    currentUser: null,
    messages: [],
    inputText: '',
    showEmojiPanel: false,
    showPlusPanel: false,
    showOrderSender: false,
    loadingHistory: false,
    isRefreshing: false,
    lastTimestamp: null,
    hasMore: true,
    scrollToView: '',
    detailText: '',
    showDetailModal: false,
    lastTapTime: 0,
    lastTapMsgId: '',
    emojiList: ['😀','😁','😂','🤣','😃','😄','😅','😆','😉','😊','😋','😎','😍','😘','😗','😙','😚','🙂','🤗','🤩','🤔','🤨','😐','😑','😶','🙄','😏','😣','😥','😮','🤐','😯','😪','😫','😴','😌','😛','😜','😝','🤤','😒','😓','😔','😕','🙃','🤑','😲','☹','🙁','😖','😞','😟','😤','😢','😭','😦','😧','😨','😩','🤯','😬','😰','😱','🥵','🥶','😳','🤪','😵','😡','😠','🤬','😷','🤒','🤕','🤢','🤮','🤧','😇','🤠','🤡','🤥','🤫','🤭','🧐','🤓','😈','👿','👹','👺','💀','👻','👽','🤖','💩','😺','😸','😹','😻','😼','😽','🙀','😿','😾'],
    pendingImage: '',
    pendingImageFile: null,
    keyboardHeight: 0,
    bottomSafeHeight: 140,
    defaultAvatarUrl: '',
  },
  onLoad(options) {
    let p = { groupId: '', groupName: '订单群聊', groupAvatar: '', orderId: '', isCross: 0,
              currentUserId: '', currentUserName: '', currentUserAvatar: '' };
    if (options.data) {
      try {
        const d = JSON.parse(decodeURIComponent(options.data));
        p = { ...p, ...d };
      } catch (e) {}
    }
    const orderIdStr = String(p.orderId || '').replace(/^group_/, '') ||
      (p.groupId && !isPairGroupId(p.groupId) ? String(p.groupId).replace(/^group_/, '') : '');
    const groupId = p.groupId
      ? String(p.groupId)
      : (orderIdStr ? `group_${orderIdStr}` : '');
    const zt = p.orderZhuangtai;
    const defAvatar = getDefaultAvatarUrl(app);
    this.setData({
      groupId,
      groupName: p.groupName,
      groupAvatar: resolveAvatarUrl(p.groupAvatar, app) || defAvatar,
      orderId: orderIdStr,
      isCross: p.isCross,
      orderJieshao: p.orderDesc || p.orderJieshao || '',
      orderJine: p.orderJine || '',
      orderZhuangtai: zt,
      orderZhuangtaiText: zt != null ? getZhuangtaiText(zt) : '',
      defaultAvatarUrl: defAvatar,
    });
    wx.setNavigationBarTitle({ title: this.data.groupName });
    this.ensureCurrentUser(p);
  },

  ensureCurrentUser(p) {
    p = p || {};
    const localImId = getLocalImUserId(app);
    const uid = wx.getStorageSync('uid') || '';
    const userId = localImId || p.currentUserId || '';
    if (!userId) {
      this.initCurrentUser();
      return;
    }
    const defAvatar = getDefaultAvatarUrl(app);
    const rawAvatar = p.currentUserAvatar
      || wx.getStorageSync('touxiang')
      || app.globalData.currentUser?.avatar
      || '';
    const name = p.currentUserName
      || app.globalData.currentUser?.name
      || wx.getStorageSync('nicheng')
      || app.globalData.dashouNicheng
      || app.globalData.nicheng
      || `用户${uid}`;
    const avatar = resolveAvatarUrl(rawAvatar, app) || defAvatar;
    const currentUser = { id: userId, name, avatar: avatar || defAvatar };
    app.globalData.currentUser = { ...app.globalData.currentUser, ...currentUser };
    this.setData({ currentUser });
  },

  getMyChatProfile() {
    const cu = this.data.currentUser;
    const defAvatar = getDefaultAvatarUrl(app);
    if (cu && cu.id) {
      return {
        id: cu.id,
        name: cu.name || `用户${wx.getStorageSync('uid') || ''}`,
        avatar: resolveAvatarUrl(cu.avatar, app) || defAvatar,
      };
    }
    const imId = getLocalImUserId(app);
    const uid = wx.getStorageSync('uid') || '';
    return {
      id: imId || '',
      name: wx.getStorageSync('nicheng') || app.globalData.nicheng || `用户${uid}`,
      avatar: resolveAvatarFromStorage(app) || defAvatar,
    };
  },
  
  initCurrentUser() {
    const profile = this.getMyChatProfile();
    if (!profile.id) return;
    this.setData({ currentUser: profile });
    app.globalData.currentUser = { ...app.globalData.currentUser, ...profile };
  },

  buildImageFile(tempPath, size) {
    return {
      path: tempPath,
      tempFilePath: tempPath,
      size: size || 0,
    };
  },

  normalizeMessage(msg) {
    if (!msg) return msg;
    msg = normalizeGroupMessage(msg);
    if (!msg.payload) msg.payload = {};
    const defAvatar = getDefaultAvatarUrl(app);
    const me = this.getMyChatProfile();
    if (me.id && msg.senderId === me.id) {
      msg.senderData = {
        name: me.name,
        avatar: me.avatar || defAvatar,
      };
    } else if (msg.senderData?.avatar) {
      msg.senderData.avatar = resolveAvatarUrl(msg.senderData.avatar, app) || defAvatar;
    } else if (msg.senderData) {
      msg.senderData.avatar = defAvatar;
    }
    if (msg.type === 'image' && msg.payload?.url && !String(msg.payload.url).startsWith('http')) {
      msg.payload.url = resolveAvatarUrl(msg.payload.url, app) || msg.payload.url;
    }
    return msg;
  },

  mapIdentityForApi() {
    const role = app.globalData.currentRole || wx.getStorageSync('currentRole') || 'normal';
    if (role === 'dashou') return 'dashou';
    if (role === 'shangjia') return 'shangjia';
    return 'normal';
  },

  async refreshLatestOrderBar() {
    const { groupId, orderId } = this.data;
    if (!groupId && !orderId) return;
    try {
      const res = await request({
        url: '/dingdan/ltpddd',
        method: 'POST',
        data: {
          groupId,
          dingdan_id: orderId,
          identityType: this.mapIdentityForApi(),
        },
      });
      const body = res?.data || {};
      const latest = body.data?.latest;
      if (!latest) return;
      this.setData({
        orderId: latest.dingdan_id,
        orderJieshao: latest.jieshao || '',
        orderJine: latest.jine || '',
        orderZhuangtai: latest.zhuangtai,
        orderZhuangtaiText: getZhuangtaiText(latest.zhuangtai),
      });
    } catch (e) {
      console.warn('刷新最新订单条失败', e);
    }
  },

  async refreshOrderStatus() {
    const { orderId } = this.data;
    if (!orderId) return;
    try {
      const res = await request({
        url: '/dingdan/ltddzt',
        method: 'POST',
        data: {
          dingdan_id: orderId,
          identityType: this.mapIdentityForApi(),
        },
      });
      const body = res?.data || {};
      const st = body.data;
      if (!st) return;
      this.setData({
        orderJieshao: st.jieshao || this.data.orderJieshao,
        orderJine: st.jine || this.data.orderJine,
        orderZhuangtai: st.zhuangtai,
        orderZhuangtaiText: getZhuangtaiText(st.zhuangtai),
      });
    } catch (e) {
      console.warn('刷新订单状态失败', e);
    }
  },

  startOrderStatusPoll() {
    this.stopOrderStatusPoll();
    this._orderPollTimer = setInterval(() => this.refreshOrderStatus(), 15000);
  },

  stopOrderStatusPoll() {
    if (this._orderPollTimer) {
      clearInterval(this._orderPollTimer);
      this._orderPollTimer = null;
    }
  },

  mergeSentMessage(localId, sent) {
    if (!sent) {
      this.updateMsg(localId, 'success');
      return;
    }
    const msgs = this.data.messages.map((m) => {
      if (m.messageId !== localId) return m;
      return this.normalizeMessage({
        ...m,
        ...sent,
        status: 'success',
        messageId: sent.messageId || m.messageId,
        payload: sent.payload || m.payload,
        senderData: m.senderData || sent.senderData,
      });
    });
    this.setData({ messages: msgs });
  },

  onShow() {
    const defAvatar = getDefaultAvatarUrl(app);
    this.setData({
      defaultAvatarUrl: defAvatar,
      groupAvatar: resolveAvatarUrl(this.data.groupAvatar, app) || defAvatar,
    });
    this.ensureCurrentUser({});
    if (this.data.groupId) {
      if (!app.globalData.pageState) app.globalData.pageState = {};
      app.globalData.pageState.lastOpenedConvId = this.data.groupId;
      recordConversationOpen({ groupId: this.data.groupId });
    }
    this.refreshLatestOrderBar();
    this.startOrderStatusPoll();
    this.autoConnect();
  },

  onHide() {
    if (this.data.groupId) {
      recordConversationOpen({ groupId: this.data.groupId });
    }
    this.stopOrderStatusPoll();
    this.clearAllListeners();
  },

  onUnload() {
    this.stopOrderStatusPoll();
  },

  async autoConnect() {
    const targetUserId = this.data.currentUser?.id || getLocalImUserId(app);
    if (!targetUserId) return;

    const afterReady = async () => {
      await this.subscribeGroupIfNeeded();
      this.setupAllListeners();
      await this.loadHistory(true);
      this.markGroupMessageAsRead();
    };

    try {
      const ok = await waitChatImReady(app, 12000);
      if (ok) {
        await afterReady();
        return;
      }
    } catch (e) {
      console.warn('[群聊] IM 连接失败', e);
    }

    const status = wx.goEasy.getConnectionStatus ? wx.goEasy.getConnectionStatus() : 'disconnected';
    if (status === 'connected' || status === 'reconnected') {
      const currentUserId = wx.goEasy.im ? wx.goEasy.im.userId : null;
      if (currentUserId === targetUserId) {
        await afterReady();
        return;
      }
      wx.goEasy.disconnect();
    }
    this.connectGoEasy(targetUserId);
  },

  connectGoEasy(userId) {
    const me = this.getMyChatProfile();
    if (!me.id) return;
    const defAvatar = getDefaultAvatarUrl(app);
    wx.goEasy.connect({
      id: userId,
      data: {
        name: me.name,
        avatar: me.avatar || defAvatar,
      },
      onSuccess: () => {
        this.subscribeGroupIfNeeded().then(() => {
          this.setupAllListeners();
          this.loadHistory(true);
          this.markGroupMessageAsRead();
        });
      },
      onFailed: (error) => {
        if (error.code === 408) {
          this.subscribeGroupIfNeeded().then(() => {
            this.setupAllListeners();
            this.loadHistory(true);
          });
        } else {
          wx.showToast({ title: '连接失败，请重试', icon: 'none' });
        }
      }
    });
  },

  subscribeGroupIfNeeded() {
    const { groupId } = this.data;
    if (!groupId || !wx.goEasy?.im?.subscribeGroup) return Promise.resolve();
    return new Promise((resolve) => {
      wx.goEasy.im.subscribeGroup({
        groupIds: [String(groupId)],
        onSuccess: () => resolve(true),
        onFailed: (error) => {
          console.warn('subscribeGroup failed', error);
          resolve(false);
        },
      });
    });
  },

  setupAllListeners() {
    this.clearAllListeners();
    this.listenNewMsg();
    this.listenRecall();
    this.listenDelete();
  },

  clearAllListeners() {
    if (this._msgHandler) { wx.goEasy.im.off(wx.GoEasy.IM_EVENT.GROUP_MESSAGE_RECEIVED, this._msgHandler); this._msgHandler = null; }
    if (this._recallHandler) { wx.goEasy.im.off(wx.GoEasy.IM_EVENT.MESSAGE_RECALLED, this._recallHandler); this._recallHandler = null; }
    if (this._deleteHandler) { wx.goEasy.im.off(wx.GoEasy.IM_EVENT.MESSAGE_DELETED, this._deleteHandler); this._deleteHandler = null; }
  },

  isConnected() {
    const s = wx.goEasy.getConnectionStatus ? wx.goEasy.getConnectionStatus() : 'disconnected';
    return s === 'connected' || s === 'reconnected';
  },

  onPullDownRefresh() {
    if (this.data.loadingHistory) return;
    if (!this.data.hasMore) {
      wx.showToast({ title: '没有更早的消息了', icon: 'none' });
      this.setData({ isRefreshing: false });
      wx.stopPullDownRefresh();
      return;
    }
    this.setData({ isRefreshing: true });
    this.loadHistory(false).finally(() => {
      this.setData({ isRefreshing: false });
      wx.stopPullDownRefresh();
    });
  },

  mapHistoryMessage(m, idx, list) {
    m = this.normalizeMessage(m);
    m.formattedTime = formatDate(m.timestamp);
    if (idx === 0) m.showTime = true;
    else m.showTime = (m.timestamp - list[idx - 1].timestamp) / 60000 > 5;
    if (!m.senderData) m.senderData = { name: '未知用户', avatar: '' };
    return m;
  },

  async fetchGroupHistoryPage(gid, lastTimestamp) {
    return fetchHistoryMessages({
      scene: wx.GoEasy.IM_SCENE.GROUP,
      id: gid,
      lastTimestamp,
      limit: 20,
    });
  },

  async loadHistory(refresh) {
    if (!refresh && !this.data.hasMore) return;
    if (this.data.loadingHistory) return;
    if (!this.data.groupId) return;

    this.setData({ loadingHistory: true });
    try {
      const ready = await waitChatImReady(app, 12000);
      if (!ready) {
        wx.showToast({ title: '消息服务未连接，请稍后重试', icon: 'none' });
        return;
      }

      await this.subscribeGroupIfNeeded();

      const ts = refresh
        ? null
        : getOldestHistoryTimestamp(this.data.messages, this.data.lastTimestamp);
      if (!refresh && ts == null) {
        this.setData({ hasMore: false });
        wx.showToast({ title: '没有更早的消息了', icon: 'none' });
        return;
      }

      let raw = await this.fetchGroupHistoryPage(this.data.groupId, ts);

      if (refresh && raw.length === 0 && isPairGroupId(this.data.groupId) && this.data.orderId) {
        const legacyId = `group_${this.data.orderId}`;
        if (legacyId !== this.data.groupId) {
          raw = await this.fetchGroupHistoryPage(legacyId, ts);
        }
      }

      const merged = mergeHistoryMessages({
        incoming: raw,
        existing: this.data.messages,
        refresh,
        limit: 20,
        mapMessage: (m, idx, list) => this.mapHistoryMessage(m, idx, list),
      });

      const update = {
        messages: merged.messages,
        hasMore: merged.hasMore,
        lastTimestamp: merged.lastTimestamp,
      };
      if (refresh) update.scrollToView = 'msg-bottom';
      this.setData(update);
    } catch (e) {
      console.warn('[群聊] 历史消息加载失败', e);
      if (!refresh) {
        wx.showToast({ title: '加载历史消息失败', icon: 'none' });
      }
    } finally {
      this.setData({ loadingHistory: false });
    }
  },

  listenNewMsg() {
    if (this._msgHandler) wx.goEasy.im.off(wx.GoEasy.IM_EVENT.GROUP_MESSAGE_RECEIVED, this._msgHandler);
    this._msgHandler = (msg) => {
      if (msg.groupId !== this.data.groupId) return;
      if (msg.senderId === this.data.currentUser.id) return;
      msg = this.normalizeMessage(msg);
      msg.formattedTime = formatDate(msg.timestamp);
      const msgs = this.data.messages;
      const last = msgs.length ? msgs[msgs.length-1] : null;
      msg.showTime = last ? (msg.timestamp - last.timestamp) / 60000 > 5 : true;
      this.setData({ messages: [...msgs, msg], scrollToView: 'msg-bottom' });
      this.markGroupMessageAsRead();
    };
    wx.goEasy.im.on(wx.GoEasy.IM_EVENT.GROUP_MESSAGE_RECEIVED, this._msgHandler);
    this.markGroupMessageAsRead();
  },

  markGroupMessageAsRead() {
    if (!this.data.groupId) return;
    wx.goEasy.im.markMessageAsRead({
      type: wx.GoEasy.IM_SCENE.GROUP,
      id: this.data.groupId
    });
  },

  listenRecall() {
    if (this._recallHandler) wx.goEasy.im.off(wx.GoEasy.IM_EVENT.MESSAGE_RECALLED, this._recallHandler);
    this._recallHandler = (msgs) => {
      if (!msgs || !msgs.length) return;
      const ids = new Set(msgs.map(m => m.messageId));
      this.setData({ messages: this.data.messages.filter(m => !ids.has(m.messageId)) });
    };
    wx.goEasy.im.on(wx.GoEasy.IM_EVENT.MESSAGE_RECALLED, this._recallHandler);
  },

  listenDelete() {
    if (this._deleteHandler) wx.goEasy.im.off(wx.GoEasy.IM_EVENT.MESSAGE_DELETED, this._deleteHandler);
    this._deleteHandler = (msgs) => {
      if (!msgs || !msgs.length) return;
      const ids = new Set(msgs.map(m => m.messageId));
      this.setData({ messages: this.data.messages.filter(m => !ids.has(m.messageId)) });
    };
    wx.goEasy.im.on(wx.GoEasy.IM_EVENT.MESSAGE_DELETED, this._deleteHandler);
  },

  onInput(e) { this.setData({ inputText: e.detail.value }); },

  chooseImage() {
    const that = this;
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success(res) {
        const file = (res.tempFiles && res.tempFiles[0]) || null;
        if (!file || !file.tempFilePath) return;
        that.setData({
          pendingImage: file.tempFilePath,
          pendingImageFile: that.buildImageFile(file.tempFilePath, file.size),
        });
      },
      fail() {
        wx.showToast({ title: '选择图片失败', icon: 'none' });
      },
    });
  },

  clearPendingImage() { this.setData({ pendingImage: '', pendingImageFile: null }); },

  sendMessage() {
    if (this.data.pendingImage) {
      this.sendImageMsg(this.data.pendingImage, this.data.pendingImageFile);
      this.setData({ pendingImage: '', pendingImageFile: null });
      return;
    }
    const text = this.data.inputText.trim();
    if (!text) return;
    this.sendText(text);
    this.setData({ inputText: '' });
  },

  sendText(text) {
    const that = this;
    sendGroupMessage({
      msgData: {
        type: 'text',
        text,
        currentUser: that.data.currentUser,
        groupId: that.data.groupId,
        orderId: that.data.orderId,
        isCross: that.data.isCross,
        groupName: that.data.groupName,
        groupAvatar: that.data.groupAvatar
      },
      onSendStart: (localMsg) => {
        const msgs = that.data.messages;
        if (msgs.length) {
          localMsg.showTime = (localMsg.timestamp - msgs[msgs.length-1].timestamp) / 60000 > 5;
        } else {
          localMsg.showTime = true;
        }
        that.setData({ messages: [...msgs, localMsg], scrollToView: 'msg-bottom' });
      },
      onSuccess: (messageId, status) => {
        that.updateMsg(messageId, status);
      }
    });
  },

  sendImageMsg(filePath, fileObj) {
    const that = this;
    const { currentUser, groupId, orderId, isCross, groupName, groupAvatar } = that.data;
    if (!filePath || !currentUser || !groupId) return;

    if (isCross === 0) {
      if (!wx.goEasy || !wx.goEasy.im) {
        wx.showToast({ title: '聊天未连接', icon: 'none' });
        return;
      }
      const avatar = resolveAvatarUrl(currentUser.avatar, app);
      const name = currentUser.name || '用户';
      const localId = `image-${Date.now()}`;
      const imageFile = fileObj || this.buildImageFile(filePath, 0);
      const localMsg = {
        messageId: localId,
        type: 'image',
        timestamp: Date.now(),
        senderId: currentUser.id,
        groupId,
        senderData: { name, avatar },
        payload: { url: filePath },
        status: 'sending',
        formattedTime: formatDate(Date.now()),
        showTime: this.needShow(Date.now()),
      };
      that.setData({ messages: [...that.data.messages, localMsg], scrollToView: 'msg-bottom' });
      const toData = { name: groupName || '订单群聊', avatar: groupAvatar || avatar, isCross: 0 };
      if (orderId) toData.orderId = orderId;
      const imgMsg = wx.goEasy.im.createImageMessage({
        file: imageFile,
        to: { type: wx.GoEasy.IM_SCENE.GROUP, id: groupId, data: toData },
      });
      wx.goEasy.im.sendMessage({
        message: imgMsg,
        onSuccess: (sent) => that.mergeSentMessage(localId, sent),
        onFailed: (error) => {
          console.error('[群聊] 图片发送失败', error);
          that.updateMsg(localId, 'failed');
          wx.showToast({ title: '图片发送失败', icon: 'none' });
        },
      });
      return;
    }

    sendGroupMessage({
      msgData: {
        type: 'image',
        filePath,
        currentUser: that.data.currentUser,
        groupId: that.data.groupId,
        orderId: that.data.orderId,
        isCross: that.data.isCross,
        groupName: that.data.groupName,
        groupAvatar: that.data.groupAvatar
      },
      onSendStart: (localMsg) => {
        const msgs = that.data.messages;
        if (msgs.length) {
          localMsg.showTime = (localMsg.timestamp - msgs[msgs.length-1].timestamp) / 60000 > 5;
        } else {
          localMsg.showTime = true;
        }
        that.setData({ messages: [...msgs, localMsg], scrollToView: 'msg-bottom' });
      },
      onSuccess: (messageId, status) => {
        that.updateMsg(messageId, status);
        if (status === 'failed') {
          wx.showToast({ title: '图片发送失败', icon: 'none' });
        }
      }
    });
  },

  updateMsg(id, status) {
    this.setData({ messages: this.data.messages.map(m => m.messageId === id ? { ...m, status } : m) });
  },

  needShow(ts) {
    const ms = this.data.messages;
    if (!ms.length) return true;
    const last = ms[ms.length-1];
    return (ts - last.timestamp) / 60000 > 5;
  },

  onBubbleTap(e) {
    const msgId = e.currentTarget.dataset.messageid;
    const text = e.currentTarget.dataset.text;
    const now = Date.now();
    if (msgId === this.data.lastTapMsgId && now - this.data.lastTapTime < 350) {
      this.setData({ detailText: text, showDetailModal: true, lastTapTime:0, lastTapMsgId:'' });
    } else {
      this.data.lastTapTime = now;
      this.data.lastTapMsgId = msgId;
    }
  },

  hideDetail() { this.setData({ showDetailModal: false }); },
  copyDetail() { wx.setClipboardData({ data: this.data.detailText }); },

  showAction(e) {
    const msgId = e.currentTarget.dataset.messageid;
    if (!msgId) return;
    const msg = this.data.messages.find(m => m.messageId === msgId);
    if (!msg || msg.messageId.startsWith('local-')) return;
    const itemList = ['复制'];
    if (msg.senderId === this.data.currentUser.id && (Date.now() - msg.timestamp < 120000) && !msg.recalled) {
      itemList.push('撤回');
    }
    itemList.push('删除');
    wx.showActionSheet({
      itemList,
      success: (res) => {
        if (itemList[res.tapIndex] === '复制') {
          if (msg.type === 'text') wx.setClipboardData({ data: msg.payload.text });
          else if (msg.type === 'order') wx.setClipboardData({ data: JSON.stringify(msg.payload) });
        } else if (itemList[res.tapIndex] === '删除') {
          this.deleteMsg(msg);
        } else if (itemList[res.tapIndex] === '撤回') {
          this.recallMsg(msg);
        }
      }
    });
  },

  deleteMsg(msg) {
    wx.showModal({
      title: '提示', content: '仅自己看不到',
      success: (res) => {
        if (res.confirm) {
          wx.goEasy.im.deleteMessage({
            messages: [msg],
            onSuccess: () => { this.setData({ messages: this.data.messages.filter(m => m.messageId !== msg.messageId) }); },
            onFailed: () => { this.setData({ messages: this.data.messages.filter(m => m.messageId !== msg.messageId) }); }
          });
        }
      }
    });
  },

  recallMsg(msg) {
    wx.showModal({
      title: '提示', content: '撤回后群内所有人都看不到该消息',
      success: (res) => {
        if (res.confirm) {
          this.setData({ messages: this.data.messages.filter(m => m.messageId !== msg.messageId) });
          wx.goEasy.im.recallMessage({ messages: [msg], onFailed:()=>{} });
        }
      }
    });
  },

  previewImage(e) { wx.previewImage({ urls: [e.currentTarget.dataset.url], current: e.currentTarget.dataset.url }); },

  togglePlusPanel() { this.setData({ showPlusPanel: !this.data.showPlusPanel, showEmojiPanel: false }); },
  closePlusPanel() { this.setData({ showPlusPanel: false }); },

  openEmojiFromPlus() { this.setData({ showPlusPanel: false, showEmojiPanel: true }); },
  toggleEmoji() { this.setData({ showEmojiPanel: !this.data.showEmojiPanel }); },
  insertEmoji(e) { this.setData({ inputText: this.data.inputText + e.currentTarget.dataset.emoji }); },
  closeEmojiPanel() { this.setData({ showEmojiPanel: false }); },

  openOrderSender() { this.setData({ showOrderSender: true, showPlusPanel: false }); },
  closeOrderSender() { this.setData({ showOrderSender: false }); },

  onSendOrder(e) {
    const order = e.detail.order;
    if (!order) return;
    const that = this;
    const payload = {
      orderId: order.dingdan_id,
      jieshao: order.jieshao,
      jine: order.jine,
      beizhu: order.beizhu,
      zhuangtai: order.zhuangtai,
      nicheng: order.nicheng,
    };
    sendGroupMessage({
      msgData: {
        type: 'order',
        orderPayload: payload,
        currentUser: that.data.currentUser,
        groupId: that.data.groupId,
        orderId: that.data.orderId,
        isCross: that.data.isCross,
        groupName: that.data.groupName,
        groupAvatar: that.data.groupAvatar
      },
      onSendStart: (localMsg) => {
        const msgs = that.data.messages;
        if (msgs.length) {
          localMsg.showTime = (localMsg.timestamp - msgs[msgs.length-1].timestamp) / 60000 > 5;
        } else {
          localMsg.showTime = true;
        }
        that.setData({ messages: [...msgs, localMsg], scrollToView: 'msg-bottom' });
      },
      onSuccess: (messageId, status) => {
        that.updateMsg(messageId, status);
        that.closeOrderSender();
        if (status === 'success') {
          wx.showToast({ title: '订单已发送', icon: 'success' });
        }
      }
    });
  },

  viewOrderDetail(e) {
    const payload = e.currentTarget.dataset.payload;
    if (!payload) return;
    const text = `订单ID: ${payload.orderId}\n内容: ${payload.jieshao}\n金额: ¥${payload.jine}\n备注: ${payload.beizhu}`;
    this.setData({ detailText: text, showDetailModal: true });
  },

  onKeyboardHeightChange(e) { this.setData({ keyboardHeight: e.detail.height }); },

  onAvatarError(e) {
    const def = getDefaultAvatarUrl(app);
    const idx = e.currentTarget.dataset.index;
    if (idx != null && idx !== '') {
      this.setData({ [`messages[${idx}].senderData.avatar`]: def });
    }
  },

  onSelfAvatarError() {
    const def = getDefaultAvatarUrl(app);
    if (this.data.currentUser) {
      this.setData({ 'currentUser.avatar': def });
    }
  },

  tapOrderBar() {
    this.openOrderSender();
  },
});