IM 消息管理方案选型与业界最佳实践

/**
 * 发送消息 - 存储转发模式
 * 客户端发送消息到服务端,服务端存储后确认成功
 */
async function sendMessage(sessionId: string, content: string, messageType: MessageType) {
  // 1. 构造消息对象
  const message = {
    sessionId,
    content,
    type: messageType,
    timestamp: Date.now()
  };

  try {
    // 2. 通过WebSocket发送消息到服务端
    const result = await window.ipcRenderer.invoke('ws:send', {
      type: 'message',
      data: message
    });

    // 3. 服务端返回消息ID,表示消息已存储成功
    console.log('消息发送成功,消息ID:', result.messageId);

    // 4. 更新本地消息状态为发送成功
    updateMessageStatus(result.tempId, MessageStatus.Sent);

    return result.messageId;
  } catch (error) {
    console.error('消息发送失败:', error);

    // 5. 更新本地消息状态为发送失败
    updateMessageStatus(message.tempId, MessageStatus.Failed);

    throw error;
  }
}

/**
 * 消息处理服务 - 存储转发模式
 */
@Injectable()
export class MessageService {
  async handleMessage(message: MessageDTO): Promise<void> {
    // 1. 生成消息ID
    const messageId = this.generateMessageId();

    // 2. 保存消息到数据库
    const savedMessage = await this.messageRepository.save({
      messageId,
      sessionId: message.sessionId,
      fromUserId: message.fromId,
      toUserId: message.toId,
      toType: message.scene === Scene.GroupChat ? 2 : 1,
      messageType: message.type,
      content: message.content,
      status: MessageStatus.Sent,
      isRevoked: false,
      isDeleted: false,
      sendTime: message.timestamp,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      version: 0
    });

    // 3. 确认消息已存储
    await this.acknowledgeMessage(message.fromId, messageId);

    // 4. 推送消息给接收方
    await this.pushMessageToReceiver(savedMessage);

    // 5. 更新会话的最后消息
    await this.sessionService.updateLastMessage(message.sessionId, {
      messageId: savedMessage.messageId,
      content: message.content,
      type: message.type,
      timestamp: message.timestamp
    });
  }

  /**
   * 生成消息ID: {timestamp}_{sequence}_{node_id}
   */
  private generateMessageId(): string {
    const timestamp = Date.now();
    const sequence = this.getNextSequence(timestamp);
    const nodeId = this.getNodeId();
    return `${timestamp}_${sequence}_${nodeId}`;
  }
}

/**
 * 发送消息 - 直推模式
 * 客户端直接推送消息,不经过服务端存储
 */
async function sendMessageDirect(sessionId: string, content: string, messageType: MessageType) {
  // 1. 构造消息对象
  const message = {
    sessionId,
    content,
    type: messageType,
    timestamp: Date.now(),
    messageId: this.generateTempMessageId() // 客户端生成临时ID
  };

  try {
    // 2. 直接通过WebSocket推送消息
    const result = await window.ipcRenderer.invoke('ws:sendDirect', {
      type: 'message_direct',
      data: message
    });

    console.log('消息推送成功');
    return result;
  } catch (error) {
    console.error('消息推送失败:', error);
    throw error;
  }
}

/**
 * 生成临时消息ID
 */
private generateTempMessageId(): string {
  return `temp_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
}

/**
 * 前端部分(渲染进程) - 消息同步管理器
 */
class MessageSyncManager {
  private wsConnection: WebSocket | null = null;
  private syncState: Map<string, SyncState> = new Map();

  /**
   * 初始化同步管理器
   */
  async initialize(): Promise<void> {
    // 1. 建立WebSocket连接(实时同步)
    this.connectWebSocket();

    // 2. 执行增量同步(拉取离线消息)
    await this.incrementalSync();

    console.log('消息同步管理器初始化完成');
  }

  /**
   * 连接WebSocket(实时同步)
   */
  private connectWebSocket(): void {
    this.wsConnection = new WebSocket('ws://your-server/ws');

    this.wsConnection.onopen = () => {
      console.log('WebSocket连接成功');
    };

    this.wsConnection.onmessage = (event) => {
      const message = JSON.parse(event.data);

      switch (message.type) {
        case 'new_message':
          this.handleNewMessage(message.data);
          break;
        case 'message_update':
          this.handleMessageUpdate(message.data);
          break;
        case 'message_revoked':
          this.handleMessageRevoked(message.data);
          break;
        case 'message_read_update':
          this.handleMessageReadUpdate(message.data);
          break;
        default:
          break;
      }
    };

    this.wsConnection.onerror = (error) => {
      console.error('WebSocket错误:', error);
      // 连接失败时,重试或降级到HTTP轮询
      this.handleWebSocketError();
    };

    this.wsConnection.onclose = () => {
      console.log('WebSocket连接关闭');
      // 自动重连
      this.reconnectWebSocket();
    };
  }

  /**
   * 增量同步(上线时执行)
   */
  private async incrementalSync(): Promise<void> {
    try {
      // 1. 从本地数据库读取同步状态
      const syncStates = await this.loadSyncStates();

      // 2. 遍历所有会话,执行增量同步
      for (const state of syncStates) {
        await this.syncSessionMessages(state);
      }

      console.log('增量同步完成');
    } catch (error) {
      console.error('增量同步失败:', error);
    }
  }

  /**
   * 同步指定会话的消息
   */
  private async syncSessionMessages(syncState: SyncState): Promise<void> {
    const response = await fetch(`/api/messages/sync`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        sessionId: syncState.sessionId,
        since: syncState.lastSyncTime,
        after: syncState.lastMessageId
      })
    });

    if (!response.ok) {
      throw new Error(`同步失败: ${response.statusText}`);
    }

    const data = await response.json();

    // 更新本地消息
    for (const message of data.messages) {
      this.updateOrInsertMessage(message);
    }

    // 更新同步状态
    syncState.lastSyncTime = data.syncTime;
    if (data.messages.length > 0) {
      syncState.lastMessageId = data.messages[data.messages.length - 1].messageId;
    }
    await this.saveSyncState(syncState);

    console.log(`会话 ${syncState.sessionId} 同步了 ${data.messages.length} 条消息`);
  }

  /**
   * 处理新消息(实时同步)
   */
  private handleNewMessage(messageData: any): void {
    // 保存到本地数据库
    this.saveMessageToLocal(messageData);

    // 更新UI
    this.updateUI();

    // 更新同步状态
    const syncState = this.syncState.get(messageData.sessionId);
    if (syncState) {
      syncState.lastSyncTime = messageData.sendTime;
      syncState.lastMessageId = messageData.messageId;
    }
  }

  /**
   * 处理消息更新(实时同步)
   */
  private handleMessageUpdate(event: MessageUpdateEvent): void {
    const { messageId, update } = event;

    // 更新本地消息
    this.updateMessage(messageId, update);

    // 更新UI
    this.updateUI();
  }

  /**
   * 处理消息撤回(实时同步)
   */
  private handleMessageRevoked(event: MessageRevokeEvent): void {
    const { messageId } = event;

    // 更新本地消息为已撤回状态
    this.revokeMessage(messageId);

    // 更新UI
    this.updateUI();
  }

  /**
   * 处理已读状态更新(实时同步)
   */
  private handleMessageReadUpdate(event: MessageReadUpdateEvent): void {
    const { messageId, userId, isRead, readTime } = event;

    // 如果是自己标记已读,更新本地消息
    if (userId === getCurrentUserId()) {
      this.updateMessageReadStatus(messageId, isRead, readTime);
      this.updateUI();
    }
  }

  /**
   * WebSocket错误处理
   */
  private handleWebSocketError(): void {
    // 降级到HTTP轮询
    console.log('降级到HTTP轮询模式');
    this.startHttpPolling();
  }

  /**
   * 自动重连WebSocket
   */
  private reconnectWebSocket(): void {
    setTimeout(() => {
      console.log('尝试重连WebSocket...');
      this.connectWebSocket();
    }, 3000); // 3秒后重连
  }

  /**
   * 启动HTTP轮询(降级方案)
   */
  private startHttpPolling(): void {
    setInterval(async () => {
      try {
        await this.incrementalSync();
      } catch (error) {
        console.error('HTTP轮询失败:', error);
      }
    }, 5000); // 每5秒轮询一次
  }
}

/**
 * 后端部分 - 消息同步服务
 */
@Injectable()
export class MessageSyncService {
  constructor(
    private messageRepository: MessageRepository,
    private messageStatusRepository: MessageStatusRepository
  ) {}

  /**
   * 增量同步消息列表
   */
  async incrementalSync(sessionId: string, since: number, after: string): Promise<SyncResponse> {
    // 1. 查询指定时间之后更新的消息
    const messages = await this.messageRepository.getMessagesBySessionIdSince(sessionId, since, after);

    // 2. 获取最新消息ID
    const lastMessageId = messages.length > 0 ? messages[messages.length - 1].messageId : after;

    // 3. 获取当前同步版本号
    const syncVersion = await this.getLatestSyncVersion();
    const syncTime = Date.now();

    return {
      messages,
      syncTime,
      syncVersion,
      lastMessageId
    };
  }

  /**
   * 获取最新的同步版本号
   */
  private async getLatestSyncVersion(): Promise<number> {
    const result = await this.messageRepository.getLatestVersion();
    return result || 0;
  }
}

/**
 * 前端部分(渲染进程) - 消息撤回服务
 */
class MessageRevokeService {
  private revokeTimeLimit: number = 2 * 60 * 1000; // 默认2分钟,可配置

  /**
   * 撤回消息
   */
  async revokeMessage(messageId: string): Promise<void> {
    const message = this.getMessage(messageId);

    if (!message) {
      throw new Error('消息不存在');
    }

    // 1. 检查是否可以撤回
    const canRevoke = await this.checkCanRevoke(message);

    if (!canRevoke) {
      throw new Error('消息无法撤回');
    }

    try {
      // 2. 请求服务端撤回消息
      await fetch(`/api/messages/${messageId}/revoke`, {
        method: 'POST'
      });

      console.log('消息撤回请求已发送');
      // 服务端会通过WebSocket推送撤回通知,客户端接收后自动更新UI
    } catch (error) {
      console.error('撤回消息失败:', error);
      throw error;
    }
  }

  /**
   * 检查消息是否可以撤回
   */
  private async checkCanRevoke(message: Message): Promise<boolean> {
    const currentUserId = getCurrentUserId();

    // 1. 检查是否是发送方
    if (message.fromUserId !== currentUserId) {
      console.log('只能撤回自己发送的消息');
      return false;
    }

    // 2. 检查是否已撤回
    if (message.isRevoked) {
      console.log('消息已被撤回');
      return false;
    }

    // 3. 检查是否超时(2分钟)
    const now = Date.now();
    if (now - message.sendTime > this.revokeTimeLimit) {
      console.log('消息发送超过2分钟,无法撤回');
      return false;
    }

    return true;
  }

  /**
   * 处理消息撤回事件(WebSocket推送)
   */
  handleMessageRevoked(event: MessageRevokeEvent): void {
    const { messageId } = event;

    const message = this.getMessage(messageId);

    if (message) {
      // 更新消息为已撤回状态
      message.isRevoked = true;

      // 保存到本地数据库
      this.saveMessageToLocal(message);

      // 更新UI
      this.updateUI();
    }
  }
}

/**
 * 后端部分 - 消息撤回服务
 */
@Injectable()
export class MessageRevokeService {
  constructor(
    private messageRepository: MessageRepository,
    private messageRevokeLogsRepository: MessageRevokeLogsRepository,
    private webSocketGateway: MessageWebSocketGateway,
    private sessionService: SessionService,
    private configService: ConfigService
  ) {}

  /**
   * 撤回消息
   */
  async revokeMessage(messageId: string, userId: number): Promise<void> {
    // 1. 检查消息是否存在
    const message = await this.messageRepository.getMessageById(messageId);
    if (!message) {
      throw new BadRequestException('消息不存在');
    }

    // 2. 检查是否是发送方
    if (message.fromUserId !== userId) {
      throw new BadRequestException('只能撤回自己发送的消息');
    }

    // 3. 检查是否已撤回
    if (message.isRevoked) {
      throw new BadRequestException('消息已被撤回');
    }

    // 4. 检查是否超时(可配置,默认2分钟)
    const revokeTimeLimit = this.configService.get<number>('revokeTimeLimit') || (2 * 60 * 1000);
    const now = Date.now();
    if (now - message.sendTime > revokeTimeLimit) {
      throw new BadRequestException('消息发送时间过长,无法撤回');
    }

    // 5. 更新消息为已撤回状态
    await this.messageRepository.updateRevokedStatus(messageId, true);

    // 6. 记录撤回操作日志
    await this.messageRevokeLogsRepository.save({
      messageId,
      operatorId: userId,
      revokeTime: Date.now(),
      deviceId: this.getDeviceId(),
      createdAt: Date.now()
    });

    // 7. 推送撤回通知给所有相关方
    await this.pushRevokeNotification(message);

    console.log(`消息 ${messageId} 已被撤回`);
  }

  /**
   * 推送撤回通知
   */
  private async pushRevokeNotification(message: Message): Promise<void> {
    if (message.toType === ToType.User) {
      // 单聊:推送给发送方和接收方
      await this.webSocketGateway.sendToUser(message.fromUserId, {
        type: 'message_revoked',
        data: { messageId: message.messageId }
      });
      await this.webSocketGateway.sendToUser(message.toUserId, {
        type: 'message_revoked',
        data: { messageId: message.messageId }
      });
    } else {
      // 群聊:推送给所有群成员
      const members = await this.sessionService.getMembersBySessionId(message.sessionId);
      for (const member of members) {
        await this.webSocketGateway.sendToUser(member.userId, {
          type: 'message_revoked',
          data: { messageId: message.messageId }
        });
      }
    }
  }
}

/**
 * 前端部分(渲染进程) - 已读回执服务
 */
class MessageReadService {
  /**
   * 标记会话消息为已读
   * 用户打开会话时调用,标记该会话所有未读消息为已读
   */
  async markSessionAsRead(sessionId: string): Promise<void> {
    const currentUserId = getCurrentUserId();

    // 1. 获取该会话的所有未读消息
    const unreadMessages = this.getUnreadMessages(sessionId);

    if (unreadMessages.length === 0) {
      return;
    }

    try {
      // 2. 请求服务端标记已读
      await fetch(`/api/messages/read`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          sessionId,
          userId: currentUserId
        })
      });

      console.log(`已发送标记已读请求,共 ${unreadMessages.length} 条消息`);
      // 服务端会通过WebSocket推送已读状态更新,客户端接收后自动更新UI
    } catch (error) {
      console.error('标记已读失败:', error);
      // 网络错误时,先更新本地UI,等待下次同步
      unreadMessages.forEach(message => {
        message.isRead = true;
        message.readTime = Date.now();
      });
      this.updateUI();
    }
  }

  /**
   * 获取会话的未读消息
   */
  private getUnreadMessages(sessionId: string): Message[] {
    return Array.from(this.messages.values())
      .filter(m => m.sessionId === sessionId && !m.isRead && m.fromUserId !== getCurrentUserId());
  }

  /**
   * 处理已读状态更新事件(WebSocket推送)
   */
  handleMessageReadUpdate(event: MessageReadUpdateEvent): void {
    const { messageId, userId, isRead, readTime } = event;

    // 如果是自己标记已读,更新本地消息
    if (userId === getCurrentUserId()) {
      const message = this.getMessage(messageId);
      if (message) {
        message.isRead = isRead;
        message.readTime = readTime;

        // 保存到本地数据库
        this.saveMessageToLocal(message);

        // 更新UI
        this.updateUI();
      }
    } else {
      // 如果是其他人标记已读,更新发送方显示的已读状态
      const message = this.getMessage(messageId);
      if (message && message.fromUserId === getCurrentUserId()) {
        // 更新消息的已读回执列表
        this.updateMessageReadReceipt(messageId, userId, isRead, readTime);
        this.updateUI();
      }
    }
  }

  /**
   * 更新消息的已读回执列表
   */
  private updateMessageReadReceipt(messageId: string, userId: number, isRead: boolean, readTime: number): void {
    // 群聊场景下,更新消息的已读回执列表
    // 单聊场景下,仅更新发送方看到的已读状态
    // 具体实现取决于业务需求
  }
}

/**
 * 后端部分 - 已读回执服务
 */
@Injectable()
export class MessageReadService {
  constructor(
    private messageRepository: MessageRepository,
    private messageStatusRepository: MessageStatusRepository,
    private webSocketGateway: MessageWebSocketGateway,
    private sessionService: SessionService
  ) {}

  /**
   * 标记会话消息为已读
   */
  async markSessionAsRead(sessionId: string, userId: number): Promise<void> {
    // 1. 获取该会话的所有未读消息
    const unreadMessages = await this.messageRepository.getUnreadMessagesBySessionId(sessionId, userId);

    if (unreadMessages.length === 0) {
      return;
    }

    // 2. 标记每条消息为已读
    const readTime = Date.now();
    for (const message of unreadMessages) {
      await this.messageStatusRepository.updateReadStatus(message.messageId, userId, true, readTime);
    }

    // 3. 推送已读状态更新给发送方
    for (const message of unreadMessages) {
      await this.pushReadNotification(message, userId, true, readTime);
    }

    // 4. 更新会话未读数
    await this.sessionService.resetUnreadCount(sessionId, userId);

    console.log(`用户 ${userId} 已标记会话 ${sessionId} 的 ${unreadMessages.length} 条消息为已读`);
  }

  /**
   * 推送已读状态更新
   */
  private async pushReadNotification(message: Message, userId: number, isRead: boolean, readTime: number): Promise<void> {
    // 推送给发送方
    await this.webSocketGateway.sendToUser(message.fromUserId, {
      type: 'message_read_update',
      data: {
        messageId: message.messageId,
        userId,
        isRead,
        readTime
      }
    });
  }
}

/**
 * 前端部分(渲染进程) - 离线消息管理器
 */
class OfflineMessageManager {
  private syncStates: Map<string, SyncState> = new Map();

  /**
   * 初始化
   */
  async initialize(): Promise<void> {
    // 1. 从本地数据库加载同步状态
    const syncStates = await this.loadSyncStates();
    syncStates.forEach(state => {
      this.syncStates.set(state.sessionId, state);
    });

    // 2. 上线时,执行增量同步(拉取离线消息)
    await this.syncOfflineMessages();

    console.log('离线消息管理器初始化完成');
  }

  /**
   * 同步离线消息(上线时执行)
   */
  async syncOfflineMessages(): Promise<void> {
    try {
      // 遍历所有会话,执行增量同步
      for (const [sessionId, syncState] of this.syncStates) {
        await this.syncSessionMessages(sessionId, syncState);
      }

      console.log('离线消息同步完成');
    } catch (error) {
      console.error('离线消息同步失败:', error);
    }
  }

  /**
   * 同步指定会话的消息
   */
  private async syncSessionMessages(sessionId: string, syncState: SyncState): Promise<void> {
    // 请求服务端消息列表(增量同步)
    const response = await fetch(`/api/messages/sync`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        sessionId,
        since: syncState.lastSyncTime,
        after: syncState.lastMessageId
      })
    });

    if (!response.ok) {
      throw new Error(`同步失败: ${response.statusText}`);
    }

    const data = await response.json();

    // 更新本地消息
    for (const message of data.messages) {
      this.updateOrInsertMessage(message);
    }

    // 更新同步状态
    syncState.lastSyncTime = data.syncTime;
    if (data.messages.length > 0) {
      syncState.lastMessageId = data.messages[data.messages.length - 1].messageId;
    }
    await this.saveSyncState(syncState);

    console.log(`会话 ${sessionId} 同步了 ${data.messages.length} 条离线消息`);
  }

  /**
   * 更新或插入消息
   */
  private updateOrInsertMessage(message: Message): void {
    const existing = this.messages.get(message.messageId);

    if (existing) {
      // 版本检查:只更新服务端版本更高的数据
      if (message.serverVersion > existing.serverVersion) {
        this.messages.set(message.messageId, message);
      }
    } else {
      // 新增消息
      this.messages.set(message.messageId, message);
    }
  }

  /**
   * 保存同步状态
   */
  private async saveSyncState(syncState: SyncState): Promise<void> {
    await window.ipcRenderer.invoke('syncStates:save', syncState);
    this.syncStates.set(syncState.sessionId, syncState);
  }
}

/**
 * 后端部分 - 离线消息服务
 */
@Injectable()
export class OfflineMessageService {
  constructor(
    private messageRepository: MessageRepository,
    private messageStatusRepository: MessageStatusRepository
  ) {}

  /**
   * 增量同步消息列表(处理离线消息)
   */
  async incrementalSync(sessionId: string, since: number, after: string): Promise<SyncResponse> {
    // 1. 查询指定时间之后更新的消息(包括离线期间的消息)
    const messages = await this.messageRepository.getMessagesBySessionIdSince(sessionId, since, after);

    // 2. 获取最新消息ID
    const lastMessageId = messages.length > 0 ? messages[messages.length - 1].messageId : after;

    // 3. 获取当前同步版本号
    const syncVersion = await this.getLatestSyncVersion();
    const syncTime = Date.now();

    return {
      messages,
      syncTime,
      syncVersion,
      lastMessageId
    };
  }

  /**
   * 获取最新的同步版本号
   */
  private async getLatestSyncVersion(): Promise<number> {
    const result = await this.messageRepository.getLatestVersion();
    return result || 0;
  }
}

/**
 * 前端部分(渲染进程) - 消息管理器初始化
 */
class MessageManager {
  private messages: Map<string, Message> = new Map();
  private sessionSyncStates: Map<string, MessageSyncState> = new Map();
  private isOnline: boolean = true;

  /**
   * 初始化消息管理器
   */
  async initialize(): Promise<void> {
    // 1. 从本地数据库加载消息
    const localMessages = await this.loadMessagesFromLocalDB();
    localMessages.forEach(message => {
      this.messages.set(message.msgId, message);
    });

    // 2. 从本地数据库加载同步状态
    const syncStates = await this.loadSyncStates();
    syncStates.forEach(state => {
      this.sessionSyncStates.set(state.sessionId, state);
    });

    // 3. 从服务端同步最新消息
    await this.syncMessagesFromServer();

    // 4. 更新UI
    this.updateUI();

    console.log('消息管理器初始化完成');
  }

  /**
   * 从本地数据库加载消息
   */
  private async loadMessagesFromLocalDB(): Promise<Message[]> {
    return await window.ipcRenderer.invoke('messages:getAll');
  }

  /**
   * 从本地数据库加载同步状态
   */
  private async loadSyncStates(): Promise<MessageSyncState[]> {
    return await window.ipcRenderer.invoke('syncStates:getAll');
  }

  /**
   * 从服务端同步消息列表
   */
  async syncMessagesFromServer(): Promise<void> {
    try {
      // 遍历所有会话,同步每个会话的消息
      for (const [sessionId, syncState] of this.sessionSyncStates) {
        await this.syncSessionMessages(sessionId, syncState);
      }

      // 持久化到本地数据库
      await this.saveMessagesToLocalDB();

      // 更新UI
      this.updateUI();

      console.log('消息同步完成');
    } catch (error) {
      console.error('同步消息失败:', error);
      // 同步失败时,使用本地缓存数据,不影响用户体验
    }
  }

  /**
   * 同步指定会话的消息
   */
  private async syncSessionMessages(sessionId: string, syncState: MessageSyncState): Promise<void> {
    // 请求服务端消息列表(增量同步)
    const response = await fetch(`/api/messages?sessionId=${sessionId}&since=${syncState.lastSyncTime}&after=${syncState.lastMessageId}`);

    if (!response.ok) {
      throw new Error(`同步失败: ${response.statusText}`);
    }

    const data = await response.json();

    // 更新本地消息
    for (const message of data.messages) {
      this.updateOrInsertMessage(message);
    }

    // 更新同步状态
    syncState.lastSyncTime = data.syncTime;
    syncState.lastSyncVersion = data.syncVersion;
    if (data.messages.length > 0) {
      syncState.lastMessageId = data.messages[data.messages.length - 1].msgId;
    }
    await this.saveSyncState(syncState);

    console.log(`会话 ${sessionId} 同步了 ${data.messages.length} 条消息`);
  }

  /**
   * 更新或插入消息
   */
  private updateOrInsertMessage(message: Message): void {
    const existing = this.messages.get(message.msgId);

    if (existing) {
      // 版本检查:只更新服务端版本更高的数据
      if (message.serverVersion > existing.serverVersion) {
        this.messages.set(message.msgId, message);
      }
    } else {
      // 新增消息
      this.messages.set(message.msgId, message);
    }
  }

  /**
   * 保存消息到本地数据库
   */
  private async saveMessagesToLocalDB(): Promise<void> {
    const messages = Array.from(this.messages.values());
    await window.ipcRenderer.invoke('messages:batchSave', messages);
  }

  /**
   * 保存同步状态
   */
  private async saveSyncState(syncState: MessageSyncState): Promise<void> {
    await window.ipcRenderer.invoke('syncStates:save', syncState);
    this.sessionSyncStates.set(syncState.sessionId, syncState);
  }

  /**
   * 更新UI
   */
  private updateUI(): void {
    const messages = this.getSortedMessages();
    this.emit('messages:updated', messages);
  }

  /**
   * 获取排序后的消息列表
   */
  private getSortedMessages(): Message[] {
    return Array.from(this.messages.values())
      .filter(m => !m.isDeleted && !m.isRevoked)
      .sort((a, b) => a.sendTime - b.sendTime);
  }
}

/**
 * 前端部分(主进程) - SQLite消息服务
 */
@Injectable()
export class MessageStorageService {
  constructor(
    @InjectDatabase() private database: Database
  ) {}

  /**
   * 批量保存消息
   */
  async saveMessages(messages: Message[]): Promise<void> {
    const stmt = await this.database.prepare(`
      INSERT OR REPLACE INTO messages (
        msg_id, session_id, from_user_id, to_user_id, to_type,
        message_type, content, media_url, media_thumb_url,
        media_size, media_duration, extra_data, status,
        is_deleted, send_time, read_time,
        created_at, updated_at, sync_time, server_version
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `);

    for (const message of messages) {
      await stmt.run(
        message.msgId,
        message.sessionId,
        message.fromUserId,
        message.toUserId,
        message.toType,
        message.messageType,
        message.content,
        message.mediaUrl,
        message.mediaThumbUrl,
        message.mediaSize,
        message.mediaDuration,
        JSON.stringify(message.extraData || {}),
        message.status,
        message.isRevoked ? 1 : 0,
        message.isDeleted ? 1 : 0,
        message.sendTime,
        message.readTime,
        message.createdAt,
        message.updatedAt,
        Date.now(),
        message.serverVersion
      );
    }

    await stmt.finalize();
  }

  /**
   * 获取所有消息
   */
  async getAllMessages(): Promise<Message[]> {
    const rows = await this.database.all(`
      SELECT * FROM messages
      ORDER BY send_time ASC
    `);

    return rows.map(this.mapRowToMessage);
  }

  /**
   * 根据会话ID获取消息
   */
  async getMessagesBySessionId(sessionId: string): Promise<Message[]> {
    const rows = await this.database.all(`
      SELECT * FROM messages WHERE session_id = ?
      ORDER BY send_time ASC
    `, [sessionId]);

    return rows.map(this.mapRowToMessage);
  }
}

/**
 * 后端部分 - 同步服务
 */
@Injectable()
export class MessageSyncService {
  /**
   * 增量同步消息列表
   */
  async incrementalSync(sessionId: string, since: number, after: string): Promise<SyncResponse> {
    // 1. 查询指定时间之后更新的消息
    const messages = await this.messageRepository.getMessagesBySessionIdSince(sessionId, since, after);

    // 2. 获取最新消息ID
    const lastMessageId = messages.length > 0 ? messages[messages.length - 1].messageId : after;

    // 3. 获取当前同步版本号
    const syncVersion = await this.getLatestSyncVersion();
    const syncTime = Date.now();

    return {
      messages,
      syncTime,
      syncVersion,
      lastMessageId
    };
  }

  /**
   * 获取最新的同步版本号
   */
  private async getLatestSyncVersion(): Promise<number> {
    const result = await this.messageRepository.getLatestVersion();
    return result || 0;
  }
}

/**
 * 前端部分(渲染进程) - 消息发送服务
 */
class MessageSender {
  /**
   * 发送消息 - 存储转发模式
   * 消息先存储到服务端,再推送给接收方
   */
  async sendMessage(sessionId: string, content: string, messageType: MessageType = MessageType.Text): Promise<string> {
    // 1. 生成临时消息ID
    const tempId = this.generateTempMessageId();

    // 2. 构造消息对象
    const message: MessageDTO = {
      tempId,
      sessionId,
      fromId: getCurrentUserId(),
      toId: await this.getToUserId(sessionId),
      scene: await this.getScene(sessionId),
      content,
      type: messageType,
      timestamp: Date.now()
    };

    try {
      // 3. 先在本地创建消息(状态为发送中)
      const localMessage: Message = {
        msgId: tempId,
        sessionId: message.sessionId,
        fromUserId: message.fromId,
        toUserId: message.toId,
        toType: message.scene === Scene.GroupChat ? 2 : 1,
        messageType: message.type,
        content: message.content,
        status: MessageStatus.Sending,
        isRevoked: false,
        isDeleted: false,
        sendTime: message.timestamp,
        createdAt: Date.now(),
        updatedAt: Date.now(),
        syncTime: Date.now(),
        serverVersion: 0
      };

      // 4. 保存到本地数据库
      await this.saveMessageToLocal(localMessage);

      // 5. 通过WebSocket发送消息到服务端
      const result = await window.ipcRenderer.invoke('ws:send', {
        type: 'message',
        data: message
      });

      // 6. 服务端返回消息ID,表示消息已存储成功
      console.log('消息发送成功,消息ID:', result.messageId);

      // 7. 更新本地消息ID和状态
      await this.updateMessageId(tempId, result.messageId);
      await this.updateMessageStatus(result.messageId, MessageStatus.Sent);

      return result.messageId;
    } catch (error) {
      console.error('消息发送失败:', error);

      // 8. 更新本地消息状态为发送失败
      await this.updateMessageStatus(tempId, MessageStatus.Failed);

      throw error;
    }
  }

  /**
   * 生成临时消息ID
   */
  private generateTempMessageId(): string {
    return `temp_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
  }

  /**
   * 获取目标用户ID
   */
  private async getToUserId(sessionId: string): Promise<number> {
    const session = await this.sessionService.getSessionById(sessionId);
    return session.targetId;
  }

  /**
   * 获取会话场景
   */
  private async getScene(sessionId: string): Promise<Scene> {
    const session = await this.sessionService.getSessionById(sessionId);
    return session.sessionType === SessionType.Group ? Scene.GroupChat : Scene.PrivateChat;
  }

  /**
   * 保存消息到本地数据库
   */
  private async saveMessageToLocal(message: Message): Promise<void> {
    await window.ipcRenderer.invoke('messages:save', message);
  }

  /**
   * 更新消息ID
   */
  private async updateMessageId(tempId: string, messageId: string): Promise<void> {
    await window.ipcRenderer.invoke('messages:updateId', { tempId, messageId });
  }

  /**
   * 更新消息状态
   */
  private async updateMessageStatus(messageId: string, status: MessageStatus): Promise<void> {
    await window.ipcRenderer.invoke('messages:updateStatus', { messageId, status });
  }
}

/**
 * 前端部分(主进程) - SQLite消息更新服务
 */
@Injectable()
export class MessageUpdateService {
  constructor(
    @InjectDatabase() private database: Database
  ) {}

  /**
   * 更新消息ID
   */
  async updateMessageId(tempId: string, messageId: string): Promise<void> {
    await this.database.run(`
      UPDATE messages SET msg_id = ? WHERE msg_id = ?
    `, [messageId, tempId]);
  }

  /**
   * 更新消息状态
   */
  async updateMessageStatus(messageId: string, status: MessageStatus): Promise<void> {
    await this.database.run(`
      UPDATE messages SET status = ?, updated_at = ? WHERE msg_id = ?
    `, [status, Date.now(), messageId]);
  }
}

/**
 * 后端部分 - 消息处理服务(存储转发模式)
 */
@Injectable()
export class MessageService {
  constructor(
    private messageRepository: MessageRepository,
    private sessionService: SessionService,
    private messageStatusRepository: MessageStatusRepository,
    private messageRevokeLogsRepository: MessageRevokeLogsRepository,
    private webSocketGateway: MessageWebSocketGateway
  ) {}

  /**
   * 处理消息(存储转发模式)
   */
  async handleMessage(message: MessageDTO): Promise<{ messageId: string }> {
    // 1. 生成消息ID: {timestamp}_{sequence}_{node_id}
    const messageId = this.generateMessageId();

    // 2. 保存消息到数据库
    const savedMessage = await this.messageRepository.save({
      messageId,
      sessionId: message.sessionId,
      fromUserId: message.fromId,
      toUserId: message.toId,
      toType: message.scene === Scene.GroupChat ? 2 : 1,
      messageType: message.type,
      content: message.content,
      status: MessageStatus.Sent,
      isRevoked: false,
      isDeleted: false,
      sendTime: message.timestamp,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      version: 0
    });

    // 3. 创建已读状态记录
    if (message.scene === Scene.PrivateChat) {
      // 单聊:为接收方创建状态记录
      await this.messageStatusRepository.create({
        messageId,
        userId: message.toId,
        isRead: false,
        isDelivered: false,
        createdAt: Date.now(),
        updatedAt: Date.now()
      });
    } else {
      // 群聊:为所有群成员创建状态记录
      const members = await this.sessionService.getMembersBySessionId(message.sessionId);
      for (const member of members) {
        if (member.userId !== message.fromId) {
          await this.messageStatusRepository.create({
            messageId,
            userId: member.userId,
            isRead: false,
            isDelivered: false,
            createdAt: Date.now(),
            updatedAt: Date.now()
          });
        }
      }
    }

    // 4. 推送消息给接收方
    await this.pushMessageToReceiver(savedMessage, message.scene);

    // 5. 更新会话的最后消息
    await this.sessionService.updateLastMessage(message.sessionId, {
      messageId: savedMessage.messageId,
      content: message.content,
      type: message.type,
      timestamp: message.timestamp
    });

    return { messageId };
  }

  /**
   * 生成消息ID: {timestamp}_{sequence}_{node_id}
   */
  private generateMessageId(): string {
    const timestamp = Date.now();
    const sequence = this.getNextSequence(timestamp);
    const nodeId = this.getNodeId();
    return `${timestamp}_${sequence}_${nodeId}`;
  }

  /**
   * 获取序列号(同一毫秒内的递增序列)
   */
  private getNextSequence(timestamp: number): number {
    // 实现序列号生成逻辑
    // 可以使用Redis或内存计数器
    return 1;
  }

  /**
   * 获取节点ID
   */
  private getNodeId(): string {
    // 可以从配置文件读取或自动生成
    return '01';
  }

  /**
   * 推送消息给接收方
   */
  private async pushMessageToReceiver(message: Message, scene: Scene): Promise<void> {
    if (scene === Scene.PrivateChat) {
      // 单聊:推送给接收方
      await this.webSocketGateway.sendToUser(message.toUserId, {
        type: 'new_message',
        data: message
      });
    } else {
      // 群聊:推送给所有群成员(除了发送方)
      const members = await this.sessionService.getMembersBySessionId(message.sessionId);
      for (const member of members) {
        if (member.userId !== message.fromUserId) {
          await this.webSocketGateway.sendToUser(member.userId, {
            type: 'new_message',
            data: message
          });
        }
      }
    }
  }
}

/**
 * 前端部分(渲染进程) - WebSocket监听新消息
 */
class MessageManager {
  private wsConnection: WebSocket | null = null;

  /**
   * 连接WebSocket
   */
  connectWebSocket(): void {
    this.wsConnection = new WebSocket('ws://your-server/ws');

    this.wsConnection.onmessage = (event) => {
      const message = JSON.parse(event.data);

      switch (message.type) {
        case 'new_message':
          this.handleNewMessage(message.data);
          break;
        case 'message_update':
          this.handleMessageUpdate(message.data);
          break;
        case 'message_revoked':
          this.handleMessageRevoked(message.data);
          break;
        default:
          break;
      }
    };
  }

  /**
   * 处理新消息事件
   */
  handleNewMessage(messageData: any): void {
    const message: Message = {
      msgId: messageData.messageId,
      sessionId: messageData.sessionId,
      fromUserId: messageData.fromUserId,
      toUserId: messageData.toUserId,
      toType: messageData.toType,
      messageType: messageData.messageType,
      content: messageData.content,
      mediaUrl: messageData.mediaUrl,
      mediaThumbUrl: messageData.mediaThumbUrl,
      mediaSize: messageData.mediaSize,
      mediaDuration: messageData.mediaDuration,
      extraData: messageData.extraData,
      status: MessageStatus.Sent,
      isRevoked: false,
      isDeleted: false,
      sendTime: messageData.sendTime,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      syncTime: Date.now(),
      serverVersion: messageData.version
    };

    // 保存到本地数据库
    this.messages.set(message.msgId, message);
    this.saveMessageToLocalDB(message);

    // 更新UI
    this.updateUI();
  }

  /**
   * 处理消息更新事件
   */
  handleMessageUpdate(event: MessageUpdateEvent): void {
    const { messageId, update } = event;

    const message = this.messages.get(messageId);

    if (message) {
      // 更新现有消息
      Object.assign(message, update);
      this.saveMessageToLocalDB(message);
      this.updateUI();
    }
  }

  /**
   * 处理消息撤回事件
   */
  handleMessageRevoked(event: MessageRevokeEvent): void {
    const { messageId } = event;

    const message = this.messages.get(messageId);

    if (message) {
      // 更新消息为已撤回状态
      message.isRevoked = true;
      this.saveMessageToLocalDB(message);
      this.updateUI();
    }
  }

  /**
   * 保存单个消息到本地数据库
   */
  private async saveMessageToLocalDB(message: Message): Promise<void> {
    await window.ipcRenderer.invoke('messages:save', message);
  }

  /**
   * 更新UI
   */
  private updateUI(): void {
    const messages = this.getSortedMessages();
    this.emit('messages:updated', messages);
  }

  /**
   * 获取排序后的消息列表
   */
  private getSortedMessages(): Message[] {
    return Array.from(this.messages.values())
      .filter(m => !m.isDeleted && !m.isRevoked)
      .sort((a, b) => a.sendTime - b.sendTime);
  }
}

/**
 * 后端部分 - WebSocket网关
 * 用于处理客户端WebSocket连接和消息推送
 */
@WebSocketGateway()
export class MessageWebSocketGateway {
  constructor(
    private eventBus: EventBus
  ) {}

  @SubscribeMessage('message')
  handleMessage(client: Socket, payload: MessageDTO): void {
    // 转发消息到消息处理服务
    this.eventBus.emit('message:handle', payload);
  }

  /**
   * 向指定用户发送WebSocket消息
   */
  sendToUser(userId: number, message: any): void {
    // 实现向指定用户发送消息的逻辑
  }
}

/**
 * 前端部分(渲染进程) - 消息撤回服务
 */
class MessageRevokeService {
  /**
   * 撤回消息
   */
  async revokeMessage(messageId: string): Promise<void> {
    const message = this.messages.get(messageId);

    if (!message) {
      throw new Error('消息不存在');
    }

    // 1. 检查是否可以撤回
    const canRevoke = await this.checkCanRevoke(message);

    if (!canRevoke) {
      throw new Error('消息无法撤回');
    }

    try {
      // 2. 请求服务端撤回消息
      await fetch(`/api/messages/${messageId}/revoke`, {
        method: 'POST'
      });

      console.log('消息撤回请求已发送');
      // 服务端会通过WebSocket推送撤回通知,客户端接收后自动更新UI
    } catch (error) {
      console.error('撤回消息失败:', error);
      throw error;
    }
  }

  /**
   * 检查消息是否可以撤回
   */
  private async checkCanRevoke(message: Message): Promise<boolean> {
    const currentUserId = getCurrentUserId();

    // 1. 检查是否是发送方
    if (message.fromUserId !== currentUserId) {
      console.log('只能撤回自己发送的消息');
      return false;
    }

    // 2. 检查是否已撤回
    if (message.isRevoked) {
      console.log('消息已被撤回');
      return false;
    }

    // 3. 检查是否已读
    const isRead = await this.checkMessageRead(message);
    if (isRead) {
      console.log('消息已读,无法撤回');
      return false;
    }

    // 4. 检查是否超时(2分钟)
    const now = Date.now();
    const revokeTimeLimit = 2 * 60 * 1000; // 2分钟
    if (now - message.sendTime > revokeTimeLimit) {
      console.log('消息发送超过2分钟,无法撤回');
      return false;
    }

    return true;
  }

  /**
   * 检查消息是否已读
   */
  private async checkMessageRead(message: Message): Promise<boolean> {
    // 单聊:检查接收方是否已读
    // 群聊:检查是否有成员已读
    // 这里简化处理,实际需要从服务端查询
    return false;
  }
}

/**
 * 后端部分 - 消息撤回服务
 */
@Injectable()
export class MessageRevokeService {
  constructor(
    private messageRepository: MessageRepository,
    private messageRevokeLogsRepository: MessageRevokeLogsRepository,
    private webSocketGateway: MessageWebSocketGateway,
    private sessionService: SessionService
  ) {}

  /**
   * 撤回消息
   */
  async revokeMessage(messageId: string, userId: number): Promise<void> {
    // 1. 检查消息是否存在
    const message = await this.messageRepository.getMessageById(messageId);
    if (!message) {
      throw new BadRequestException('消息不存在');
    }

    // 2. 检查是否是发送方
    if (message.fromUserId !== userId) {
      throw new BadRequestException('只能撤回自己发送的消息');
    }

    // 3. 检查是否已撤回
    if (message.isRevoked) {
      throw new BadRequestException('消息已被撤回');
    }

    // 4. 检查是否已读
    const isRead = await this.checkMessageRead(message);
    if (isRead) {
      throw new BadRequestException('消息已读,无法撤回');
    }

    // 5. 检查是否超时(2分钟)
    const now = Date.now();
    const revokeTimeLimit = 2 * 60 * 1000; // 2分钟
    if (now - message.sendTime > revokeTimeLimit) {
      throw new BadRequestException('消息发送超过2分钟,无法撤回');
    }

    // 6. 更新消息为已撤回状态
    await this.messageRepository.updateRevokedStatus(messageId, true);

    // 7. 记录撤回操作日志
    await this.messageRevokeLogsRepository.save({
      messageId,
      operatorId: userId,
      revokeTime: Date.now(),
      createdAt: Date.now()
    });

    // 8. 推送撤回通知给所有相关方
    await this.pushRevokeNotification(message);
  }

  /**
   * 检查消息是否已读
   */
  private async checkMessageRead(message: Message): Promise<boolean> {
    // 单聊:检查接收方是否已读
    if (message.toType === 1) {
      const status = await this.messageStatusRepository.getByMessageIdAndUserId(
        message.messageId,
        message.toUserId
      );
      return status?.isRead || false;
    } else {
      // 群聊:检查是否有成员已读
      const statuses = await this.messageStatusRepository.getByMessageId(message.messageId);
      return statuses.some(status => status.isRead);
    }
  }

  /**
   * 推送撤回通知
   */
  private async pushRevokeNotification(message: Message): Promise<void> {
    if (message.toType === 1) {
      // 单聊:推送给发送方和接收方
      await this.webSocketGateway.sendToUser(message.fromUserId, {
        type: 'message_revoked',
        data: { messageId: message.messageId }
      });
      await this.webSocketGateway.sendToUser(message.toUserId, {
        type: 'message_revoked',
        data: { messageId: message.messageId }
      });
    } else {
      // 群聊:推送给所有群成员
      const members = await this.sessionService.getMembersBySessionId(message.sessionId);
      for (const member of members) {
        await this.webSocketGateway.sendToUser(member.userId, {
          type: 'message_revoked',
          data: { messageId: message.messageId }
        });
      }
    }
  }
}

/**
 * 前端部分(渲染进程) - 已读回执服务
 */
class MessageReadService {
  /**
   * 标记会话消息为已读
   * 用户打开会话时调用,标记该会话所有未读消息为已读
   */
  async markSessionAsRead(sessionId: string): Promise<void> {
    const currentUserId = getCurrentUserId();

    // 1. 获取该会话的所有未读消息
    const unreadMessages = Array.from(this.messages.values())
      .filter(m => m.sessionId === sessionId && !m.isRead);

    if (unreadMessages.length === 0) {
      return;
    }

    try {
      // 2. 请求服务端标记已读
      await fetch(`/api/messages/read`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          sessionId,
          userId: currentUserId
        })
      });

      console.log(`已发送标记已读请求,共 ${unreadMessages.length} 条消息`);
      // 服务端会通过WebSocket推送已读状态更新,客户端接收后自动更新UI
    } catch (error) {
      console.error('标记已读失败:', error);
      // 网络错误时,先更新本地UI,等待下次同步
      unreadMessages.forEach(message => {
        message.isRead = true;
        message.readTime = Date.now();
      });
      this.updateUI();
    }
  }

  /**
   * 处理已读状态更新事件
   */
  handleMessageReadUpdate(event: MessageReadUpdateEvent): void {
    const { messageId, userId, isRead, readTime } = event;

    // 如果是自己标记已读,更新本地消息
    if (userId === getCurrentUserId()) {
      const message = this.messages.get(messageId);
      if (message) {
        message.isRead = isRead;
        message.readTime = readTime;
        this.saveMessageToLocalDB(message);
        this.updateUI();
      }
    }
  }
}

/**
 * 后端部分 - 已读回执服务
 */
@Injectable()
export class MessageReadService {
  constructor(
    private messageStatusRepository: MessageStatusRepository,
    private webSocketGateway: MessageWebSocketGateway,
    private sessionService: SessionService
  ) {}

  /**
   * 标记会话消息为已读
   */
  async markSessionAsRead(sessionId: string, userId: number): Promise<void> {
    // 1. 获取该会话的所有未读消息
    const unreadMessages = await this.messageRepository.getUnreadMessagesBySessionId(sessionId, userId);

    // 2. 标记每条消息为已读
    const readTime = Date.now();
    for (const message of unreadMessages) {
      await this.messageStatusRepository.updateReadStatus(message.messageId, userId, true, readTime);
    }

    // 3. 推送已读状态更新给发送方
    for (const message of unreadMessages) {
      await this.pushReadNotification(message, userId, true, readTime);
    }

    // 4. 更新会话未读数
    await this.sessionService.resetUnreadCount(sessionId, userId);
  }

  /**
   * 推送已读状态更新
   */
  private async pushReadNotification(message: Message, userId: number, isRead: boolean, readTime: number): Promise<void> {
    // 推送给发送方
    await this.webSocketGateway.sendToUser(message.fromUserId, {
      type: 'message_read_update',
      data: {
        messageId: message.messageId,
        userId,
        isRead,
        readTime
      }
    });
  }
}

/**
 * 前端部分(渲染进程) - 消息删除服务
 */
class MessageDeleteService {
  /**
   * 删除消息(本地删除)
   * 仅在本地删除,不影响其他客户端
   */
  async deleteMessageLocal(messageId: string): Promise<void> {
    const message = this.messages.get(messageId);

    if (!message) {
      throw new Error('消息不存在');
    }

    try {
      // 1. 标记本地消息为已删除
      message.isDeleted = true;

      // 2. 持久化到本地数据库
      await this.saveMessageToLocalDB(message);

      // 3. 更新UI
      this.updateUI();

      console.log('消息已本地删除');
    } catch (error) {
      console.error('删除消息失败:', error);
      throw error;
    }
  }

  /**
   * 删除消息(服务端删除)
   * 在服务端删除,所有客户端同步删除
   */
  async deleteMessageServer(messageId: string): Promise<void> {
    const message = this.messages.get(messageId);

    if (!message) {
      throw new Error('消息不存在');
    }

    try {
      // 1. 请求服务端删除消息
      await fetch(`/api/messages/${messageId}`, {
        method: 'DELETE'
      });

      console.log('消息删除请求已发送');
      // 服务端会通过WebSocket推送删除通知,客户端接收后自动更新UI
    } catch (error) {
      console.error('删除消息失败:', error);
      throw error;
    }
  }

  /**
   * 处理消息删除事件
   */
  handleMessageDeleted(event: MessageDeleteEvent): void {
    const { messageId } = event;

    const message = this.messages.get(messageId);

    if (message) {
      // 更新消息为已删除状态
      message.isDeleted = true;
      this.saveMessageToLocalDB(message);
      this.updateUI();
    }
  }
}

/**
 * 后端部分 - 消息删除服务
 */
@Injectable()
export class MessageDeleteService {
  constructor(
    private messageRepository: MessageRepository,
    private webSocketGateway: MessageWebSocketGateway,
    private sessionService: SessionService
  ) {}

  /**
   * 删除消息(服务端删除)
   */
  async deleteMessage(messageId: string, userId: number): Promise<void> {
    // 1. 检查消息是否存在
    const message = await this.messageRepository.getMessageById(messageId);
    if (!message) {
      throw new BadRequestException('消息不存在');
    }

    // 2. 检查是否是发送方
    if (message.fromUserId !== userId) {
      throw new BadRequestException('只能删除自己发送的消息');
    }

    // 3. 标记消息为已删除(软删除)
    await this.messageRepository.updateDeletedStatus(messageId, true);

    // 4. 推送删除通知给所有相关方
    await this.pushDeleteNotification(message);
  }

  /**
   * 推送删除通知
   */
  private async pushDeleteNotification(message: Message): Promise<void> {
    if (message.toType === 1) {
      // 单聊:推送给发送方和接收方
      await this.webSocketGateway.sendToUser(message.fromUserId, {
        type: 'message_deleted',
        data: { messageId: message.messageId }
      });
      await this.webSocketGateway.sendToUser(message.toUserId, {
        type: 'message_deleted',
        data: { messageId: message.messageId }
      });
    } else {
      // 群聊:推送给所有群成员
      const members = await this.sessionService.getMembersBySessionId(message.sessionId);
      for (const member of members) {
        await this.webSocketGateway.sendToUser(member.userId, {
          type: 'message_deleted',
          data: { messageId: message.messageId }
        });
      }
    }
  }
}