IM 会话管理方案选型与业界最佳实践

// 伪代码：仅用于展示核心逻辑，非完整实现

/**
 * 发送消息 - 隐式创建会话
 * 客户端直接发送消息，无需先创建会话
 */
async function sendMessage(toId: number, content: string, scene: Scene) {
  // 直接发送消息，无需检查会话是否存在
  const message = {
    toId,
    content,
    scene,
    type: MessageType.Text,
    timestamp: Date.now()
  };

  try {
    // 通过WebSocket发送消息到服务端
    await ws.send(JSON.stringify({
      type: 'message',
      data: message
    }));

    // 服务端会自动创建会话（如果不存在）并返回消息ID
    console.log('消息发送成功');
  } catch (error) {
    console.error('消息发送失败:', error);
    throw new Error('消息发送失败');
  }
}

// 类型定义（伪代码）
enum Scene {
  PrivateChat = 1,
  GroupChat = 2
}

enum MessageType {
  Text = 1,
  Image = 2,
  Voice = 3,
  Video = 4
}

// WebSocket连接管理（伪代码）
const ws = new WebSocket('wss://your-im-server.com/ws');
ws.onopen = () => console.log('WebSocket连接已建立');
ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  // 处理服务端返回的消息
  if (data.type === 'message_ack') {
    console.log('消息已确认:', data.messageId);
  } else if (data.type === 'new_session') {
    console.log('新会话创建:', data.session);
    // 更新会话列表
  }
};

// 伪代码：仅用于展示核心逻辑，非完整实现

/**
 * 消息处理服务 - 隐式创建会话
 */
@Injectable()
export class MessageService {
  constructor(
    private sessionRepository: SessionRepository,
    private privateSessionExtRepository: PrivateSessionExtRepository,
    private groupSessionExtRepository: GroupSessionExtRepository,
    private sessionMembersRepository: SessionMembersRepository,
    private sessionOperationLogsRepository: SessionOperationLogsRepository,
    private websocketService: WebsocketService
  ) {}

  async handleMessage(message: MessageDTO) {
    try {
      // 1. 检查会话是否存在
      let sessionId = await this.getSessionId(message.toId, message.scene);

      // 2. 如果会话不存在，自动创建
      if (!sessionId) {
        sessionId = await this.createSession(message);
      }

      // 3. 保存消息
      const savedMessage = await this.saveMessage({
        ...message,
        sessionId
      });

      // 4. 更新会话的最后消息
      await this.updateSessionLastMessage(sessionId, savedMessage);

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

      return sessionId;
    } catch (error) {
      console.error('处理消息失败:', error);
      throw error;
    }
  }

  /**
   * 获取会话ID
   */
  private async getSessionId(toId: number, scene: Scene): Promise<string | null> {
    // 实现逻辑：根据接收者ID和场景查询会话
    // 伪代码实现
    if (scene === Scene.PrivateChat) {
      const currentUserId = this.getCurrentUserId();
      const userIds = [currentUserId, toId].sort((a, b) => a - b);
      return `${userIds[0]}_${userIds[1]}`;
    } else {
      // 群聊场景：返回群ID作为会话ID（群ID即为会话ID）
      // 注意：隐式创建模式下，群聊会话的toId即为群组ID，该ID在创建群组时已生成并作为会话ID
      return toId.toString();
    }
  }

  /**
   * 保存消息
   */
  private async saveMessage(message: any) {
    // 实现逻辑：保存消息到数据库
    // 伪代码实现
    return message;
  }

  /**
   * 更新会话最后消息
   */
  private async updateSessionLastMessage(sessionId: string, message: any) {
    // 实现逻辑：更新会话的最后消息信息
    // 伪代码实现
    await this.sessionRepository.update({
      sessionId,
      lastMessageId: message.id,
      lastMessageContent: message.content,
      lastMessageType: message.type,
      lastMessageTime: message.timestamp,
      updatedAt: Date.now()
    });
  }

  /**
   * 推送消息
   */
  private async pushMessage(message: any) {
    // 实现逻辑：通过WebSocket推送消息给接收方
    // 伪代码实现
    await this.websocketService.sendMessageToUser(message.toId, {
      type: 'new_message',
      data: message
    });
  }

  /**
   * 自动创建会话
   */
  private async createSession(message: MessageDTO): Promise<string> {
    // 1. 生成会话ID
    const sessionId = this.generateSessionId(message.toId, message.scene);

    // 2. 检查会话类型，判断是单聊还是群聊
    const isGroupChat = message.scene === Scene.GroupChat;

    if (isGroupChat) {
      // 群聊：toId即为群组ID（群聊会话的toId已在创建群组时生成，此处直接使用）
      // 注：群聊的会话ID就是群组ID，不需要重新生成UUID
      await this.createGroupSession(message, sessionId);
    } else {
      // 单聊：创建单聊会话
      await this.createPrivateSession(message, sessionId);
    }

    // 3. 推送新会话给发送方
    await this.pushNewSession(sessionId, message.fromId);

    // 4. 推送新会话给接收方
    await this.pushNewSession(sessionId, message.toId);

    return sessionId;
  }

  /**
   * 生成会话ID
   */
  private generateSessionId(toId: number, scene: Scene): string {
    if (scene === Scene.PrivateChat) {
      const currentUserId = this.getCurrentUserId();
      const userIds = [currentUserId, toId].sort((a, b) => a - b);
      return `${userIds[0]}_${userIds[1]}`;
    } else {
      // 群聊：toId即为群组ID（群聊会话的toId在创建群组时已生成，此处直接使用）
      // 注：群聊的会话ID就是群组ID，不需要重新生成UUID
      return toId.toString();
    }
  }

  /**
   * 生成UUID
   */
  private generateUUID(): string {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
      const r = Math.random() * 16 | 0;
      const v = c === 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  }

  /**
   * 获取当前用户ID
   */
  private getCurrentUserId(): number {
    // 实现逻辑：从上下文获取当前用户ID
    // 伪代码实现
    return 10001;
  }

  /**
   * 推送新会话
   */
  private async pushNewSession(sessionId: string, userId: number) {
    // 实现逻辑：推送新会话给用户
    // 伪代码实现
    const session = await this.sessionRepository.getSessionById(sessionId);
    await this.websocketService.sendMessageToUser(userId, {
      type: 'new_session',
      data: session
    });
  }

  /**
   * 创建单聊会话（隐式创建）
   */
  private async createPrivateSession(message: MessageDTO, sessionId: string): Promise<void> {
    const userIds = [message.fromId, message.toId].sort((a, b) => a - b);

    // 1. 保存会话基本信息到session_base_info表
    await this.sessionRepository.save({
      sessionId,
      sessionType: SessionType.Private,
      lastMessageId: '',
      lastMessageContent: message.content,
      lastMessageType: message.type,
      lastMessageTime: message.timestamp,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      version: 0
    });

    // 2. 保存单聊扩展信息到session_private_ext表
    await this.privateSessionExtRepository.save({
      sessionId,
      userId1: userIds[0],
      userId2: userIds[1],
      createdAt: Date.now(),
      updatedAt: Date.now()
    });

    // 3. 创建会话成员到session_members表（两个用户）
    await this.sessionMembersRepository.createMember({
      sessionId,
      userId: userIds[0],
      role: MemberRole.Member,
      unreadCount: 0,
      isTop: false,
      isMuted: false,
      isDeleted: false,
      joinTime: Date.now(),
      isActive: true,
      createdAt: Date.now(),
      updatedAt: Date.now()
    });
    
    await this.sessionMembersRepository.createMember({
      sessionId,
      userId: userIds[1],
      role: MemberRole.Member,
      unreadCount: 0,
      isTop: false,
      isMuted: false,
      isDeleted: false,
      joinTime: Date.now(),
      isActive: true,
      createdAt: Date.now(),
      updatedAt: Date.now()
    });

    // 4. 记录操作日志
    await this.sessionOperationLogsRepository.save({
      sessionId,
      operatorId: message.fromId,
      operationType: 7, // 7-自动创建
      operationTime: Date.now(),
      createdAt: Date.now()
    });
  }

  /**
   * 创建群聊会话（隐式创建）
   */
  private async createGroupSession(message: MessageDTO, sessionId: string): Promise<void> {
    // 1. 保存会话基本信息到session_base_info表
    await this.sessionRepository.save({
      sessionId,
      sessionType: SessionType.Group,
      lastMessageId: '',
      lastMessageContent: message.content,
      lastMessageType: message.type,
      lastMessageTime: message.timestamp,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      version: 0
    });

    // 2. 保存群聊扩展信息到session_group_ext表
    await this.groupSessionExtRepository.save({
      sessionId,
      groupName: message.groupName || '群聊',
      groupAvatar: message.groupAvatar || '',
      announcement: '',
      maxMembers: 500,
      joinPermission: 1,
      messagePermission: 1,
      createdAt: Date.now(),
      updatedAt: Date.now()
    });

    // 3. 创建会话成员到session_members表（群聊成员）
    // 注：隐式创建模式下，群聊成员应从群组管理中获取，不包含在message中
    //     这里假设members字段已从群组管理中获取
    const members = message.members || [message.fromId];
    for (const memberId of members) {
      await this.sessionMembersRepository.createMember({
        sessionId,
        userId: memberId,
        role: memberId === message.fromId ? MemberRole.Owner : MemberRole.Member,
        unreadCount: 0,
        isTop: false,
        isMuted: false,
        isDeleted: false,
        joinTime: Date.now(),
        isActive: true,
        createdAt: Date.now(),
        updatedAt: Date.now()
      });
    }

    // 4. 记录操作日志
    await this.sessionOperationLogsRepository.save({
      sessionId,
      operatorId: message.fromId,
      operationType: 7, // 7-自动创建
      operationTime: Date.now(),
      createdAt: Date.now()
    });
  }
}

// 类型定义（伪代码）
enum Scene {
  PrivateChat = 1,
  GroupChat = 2
}

enum SessionType {
  Private = 1,
  Group = 2,
  System = 3
}

enum MemberRole {
  Member = 1,
  Admin = 2,
  Owner = 3
}

// DTO定义（伪代码）
class MessageDTO {
  fromId: number;
  toId: number;
  content: string;
  type: number;
  scene: Scene;
  timestamp: number;
  groupName?: string;
  groupAvatar?: string;
  members?: number[];
}

// 伪代码：仅用于展示核心逻辑，非完整实现

/**
 * 创建会话 - 显式创建
 * 用户需要先创建会话，然后才能发送消息
 */
async function createSession(toId: number, scene: Scene) {
  try {
    // 1. 先检查会话是否已存在
    const existingSession = await checkSessionExist(toId, scene);

    if (existingSession) {
      console.log('会话已存在');
      return existingSession.sessionId;
    }

    // 2. 请求服务端创建会话
    const response = await fetch('/api/sessions', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ toId, scene })
    });

    if (!response.ok) {
      throw new Error('创建会话失败');
    }

    const session = await response.json();

    // 3. 会话创建成功后，才能发送消息
    if (session.success) {
      console.log('会话创建成功，可以发送消息');
      return session.sessionId;
    } else {
      throw new Error(session.message || '创建会话失败');
    }
  } catch (error) {
    console.error('创建会话失败:', error);
    throw error;
  }
}

/**
 * 检查会话是否存在
 */
async function checkSessionExist(toId: number, scene: Scene): Promise<any> {
  try {
    const response = await fetch(`/api/sessions/check?toId=${toId}&scene=${scene}`);
    const result = await response.json();
    return result.exists ? result.session : null;
  } catch (error) {
    console.error('检查会话失败:', error);
    return null;
  }
}

/**
 * 发送消息 - 显式创建模式
 * 需要先确保会话存在
 */
async function sendMessage(sessionId: string, content: string) {
  // 检查会话是否存在
  if (!sessionId) {
    throw new Error('会话不存在，请先创建会话');
  }

  try {
    // 发送消息
    const message = {
      sessionId,
      content,
      type: MessageType.Text,
      timestamp: Date.now()
    };

    await ws.send(JSON.stringify({
      type: 'message',
      data: message
    }));

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

// 类型定义（伪代码）
enum Scene {
  PrivateChat = 1,
  GroupChat = 2
}

enum MessageType {
  Text = 1,
  Image = 2,
  Voice = 3,
  Video = 4
}

// 伪代码：仅用于展示核心逻辑，非完整实现

/**
 * 会话管理服务 - 显式创建会话
 */
@Injectable()
export class SessionService {
  constructor(
    private sessionRepository: SessionRepository,
    private privateSessionExtRepository: PrivateSessionExtRepository,
    private groupSessionExtRepository: GroupSessionExtRepository,
    private sessionMembersRepository: SessionMembersRepository,
    private sessionOperationLogsRepository: SessionOperationLogsRepository,
    private websocketService: WebsocketService
  ) {}

  /**
   * 创建会话（显式创建）
   */
  async createSession(dto: CreateSessionDTO): Promise<Session> {
    try {
      const currentUserId = this.getCurrentUserId();
      const { toId } = dto;
      
      // 1. 判断会话类型并生成会话ID
      const isGroupChat = dto.isGroupChat || false;
      
      let sessionId: string;
      
      if (isGroupChat) {
        // 群聊：生成UUID
        sessionId = this.generateUUID();
      } else {
        // 单聊：生成会话ID（小用户ID_大用户ID）
        const userIds = [currentUserId, toId].sort((a, b) => a - b);
        sessionId = `${userIds[0]}_${userIds[1]}`;
      }

      // 2. 检查会话是否已存在
      const existing = await this.sessionRepository.getSessionById(sessionId);
      if (existing) {
        throw new BadRequestException('会话已存在');
      }

      // 3. 创建会话基本信息
      const sessionType = isGroupChat ? SessionType.Group : SessionType.Private;
      await this.createBaseSession({
        sessionId,
        sessionType
      });

      // 4. 根据会话类型保存扩展信息
      if (isGroupChat) {
        // 群聊扩展信息
        await this.groupSessionExtRepository.save({
          sessionId,
          groupName: dto.groupName || '群聊',
          groupAvatar: dto.groupAvatar || '',
          announcement: '',
          maxMembers: 500,
          joinPermission: 1,
          messagePermission: 1,
          createdAt: Date.now(),
          updatedAt: Date.now()
        });
      } else {
        // 单聊扩展信息
        const userIds = [currentUserId, toId].sort((a, b) => a - b);
        await this.privateSessionExtRepository.save({
          sessionId,
          userId1: userIds[0],
          userId2: userIds[1],
          createdAt: Date.now(),
          updatedAt: Date.now()
        });
      }

      // 5. 创建会话成员
      if (isGroupChat) {
        // 群聊：创建群主和成员
        const members = dto.memberIds || [];
        await this.createMember({
          sessionId,
          userId: currentUserId,
          role: MemberRole.Owner
        });
        
        for (const memberId of members) {
          await this.createMember({
            sessionId,
            userId: memberId,
            role: MemberRole.Member
          });
        }
      } else {
        // 单聊：创建两个成员
        const userIds = [currentUserId, toId].sort((a, b) => a - b);
        await this.createMember({
          sessionId,
          userId: userIds[0],
          role: MemberRole.Member
        });
        await this.createMember({
          sessionId,
          userId: userIds[1],
          role: MemberRole.Member
        });
      }

      // 6. 记录操作日志
      await this.sessionOperationLogsRepository.save({
        sessionId,
        operatorId: currentUserId,
        operationType: 7, // 7-创建会话
        operationTime: Date.now(),
        createdAt: Date.now()
      });

      // 7. 获取完整的会话信息
      const session = await this.sessionRepository.getSessionById(sessionId);

      // 8. 推送新会话给所有参与者
      const memberIds = isGroupChat 
        ? [currentUserId, ...(dto.memberIds || [])]
        : [currentUserId, toId];
      await this.pushNewSession(session, memberIds);

      return session;
    } catch (error) {
      console.error('创建会话失败:', error);
      throw error;
    }
  }

  /**
   * 获取当前用户ID
   */
  private getCurrentUserId(): number {
    // 实现逻辑：从上下文获取当前用户ID
    // 伪代码实现
    return 10001;
  }

  /**
   * 推送新会话
   */
  private async pushNewSession(session: Session, memberIds: number[]) {
    // 实现逻辑：推送新会话给所有成员
    // 伪代码实现
    for (const memberId of memberIds) {
      await this.websocketService.sendMessageToUser(memberId, {
        type: 'new_session',
        data: session
      });
    }
  }

  /**
   * 创建会话基本信息
   */
  private async createBaseSession(dto: {
    sessionId: string,
    sessionType: SessionType
  }): Promise<void> {
    await this.sessionRepository.save({
      sessionId,
      sessionType,
      lastMessageId: '',
      lastMessageContent: '',
      lastMessageType: null,
      lastMessageTime: 0,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      version: 0
    });
  }

  /**
   * 创建会话成员
   */
  private async createMember(dto: {
    sessionId: string,
    userId: number,
    role: MemberRole
  }): Promise<void> {
    await this.sessionMembersRepository.create({
      sessionId,
      userId,
      role,
      unreadCount: 0,
      isTop: false,
      isMuted: false,
      isDeleted: false,
      joinTime: Date.now(),
      isActive: true,
      createdAt: Date.now(),
      updatedAt: Date.now()
    });
  }

  /**
   * 生成UUID（用于群聊会话ID）
   */
  private generateUUID(): string {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
      const r = Math.random() * 16 | 0;
      const v = c === 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  }
}

// 类型定义（伪代码）
enum SessionType {
  Private = 1,
  Group = 2,
  System = 3
}

enum MemberRole {
  Member = 1,
  Admin = 2,
  Owner = 3
}

// DTO定义（伪代码）
class CreateSessionDTO {
  toId: number;
  isGroupChat?: boolean;
  groupName?: string;
  groupAvatar?: string;
  memberIds?: number[];
}

class Session {
  sessionId: string;
  sessionType: SessionType;
  lastMessageId: string;
  lastMessageContent: string;
  lastMessageType: number | null;
  lastMessageTime: number;
  createdAt: number;
  updatedAt: number;
  version: number;
}

// 异常类（伪代码）
class BadRequestException extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'BadRequestException';
  }
}

/**
 * 前端部分(渲染进程) - 会话管理器初始化
 */
class SessionManager {
  private sessions: Map<string, Session> = new Map();
  private lastSyncTime: number = 0;
  private lastSyncVersion: number = 0;
  private isOnline: boolean = true;

  /**
   * 初始化会话管理器
   */
  async initialize(): Promise<void> {
    // 1. 从本地数据库加载会话
    const localSessions = await this.loadSessionsFromLocalDB();
    localSessions.forEach(session => {
      this.sessions.set(session.sid, session);
    });

    // 2. 从本地数据库加载同步状态
    const syncState = await this.loadSyncState();
    if (syncState) {
      this.lastSyncTime = syncState.lastSyncTime;
      this.lastSyncVersion = syncState.lastSyncVersion;
    }

    // 3. 从服务端同步最新会话
    await this.syncSessionsFromServer();

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

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

  /**
   * 从本地数据库加载会话
   */
  private async loadSessionsFromLocalDB(): Promise<Session[]> {
    return await window.ipcRenderer.invoke('sessions:getAll');
  }

  /**
   * 从本地数据库加载同步状态
   */
  private async loadSyncState(): Promise<SyncState | null> {
    return await window.ipcRenderer.invoke('syncState:get');
  }

  /**
   * 从服务端同步会话列表
   */
  async syncSessionsFromServer(): Promise<void> {
    try {
      // 请求服务端会话列表(增量同步)
      const response = await fetch(`/api/sessions?since=${this.lastSyncTime}&version=${this.lastSyncVersion}`);

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

      const data = await response.json();

      // 更新本地会话
      for (const session of data.sessions) {
        this.updateOrInsertSession(session);
      }

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

      // 更新同步状态
      this.lastSyncTime = data.syncTime;
      this.lastSyncVersion = data.syncVersion;
      await this.saveSyncState();

      // 更新UI
      this.updateUI();

      console.log(`同步了 ${data.sessions.length} 个会话`);
    } catch (error) {
      console.error('同步会话失败:', error);
      // 同步失败时，使用本地缓存数据，不影响用户体验
    }
  }

  /**
   * 更新或插入会话
   */
  private updateOrInsertSession(session: Session): void {
    const existing = this.sessions.get(session.sid);

    if (existing) {
      // 版本检查：只更新服务端版本更高的数据
      if (session.serverVersion > existing.serverVersion) {
        this.sessions.set(session.sid, session);
      }
    } else {
      // 新增会话
      this.sessions.set(session.sid, session);
    }
  }

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

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

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

  /**
   * 获取排序后的会话列表
   */
  private getSortedSessions(): Session[] {
    return Array.from(this.sessions.values())
      .filter(s => !s.isDeleted)
      .sort((a, b) => {
        // 置顶的排前面
        if (a.isTop && !b.isTop) return -1;
        if (!a.isTop && b.isTop) return 1;

        // 按最后消息时间倒序
        return b.lastMessageTime - a.lastMessageTime;
      });
  }
}

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

  /**
   * 批量保存会话
   */
  async saveSessions(sessions: Session[]): Promise<void> {
    const stmt = await this.database.prepare(`
      INSERT OR REPLACE INTO sessions (
        sid, session_type, target_id, target_name, target_avatar,
        last_message_id, last_message_content, last_message_type,
        last_message_time, unread_count, is_top, is_muted, is_deleted,
        created_at, updated_at, sync_time, server_version
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `);

    for (const session of sessions) {
      await stmt.run(
        session.sid,
        session.sessionType,
        session.targetId,
        session.targetName,
        session.targetAvatar,
        session.lastMessageId,
        session.lastMessageContent,
        session.lastMessageType,
        session.lastMessageTime,
        session.unreadCount,
        session.isTop ? 1 : 0,
        session.isMuted ? 1 : 0,
        session.isDeleted ? 1 : 0,
        session.createdAt,
        session.updatedAt,
        Date.now(),
        session.serverVersion
      );
    }

    await stmt.finalize();
  }

  /**
   * 获取所有会话
   */
  async getAllSessions(): Promise<Session[]> {
    const rows = await this.database.all(`
      SELECT * FROM sessions WHERE is_deleted = 0
      ORDER BY is_top DESC, last_message_time DESC
    `);

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

/**
 * 前端部分(主进程) - 同步状态服务
 */
@Injectable()
export class SyncStateService {
  constructor(
    @InjectDatabase() private database: Database
  ) {}

  /**
   * 获取同步状态
   */
  async getSyncState(): Promise<SyncState | null> {
    const row = await this.database.get(`
      SELECT * FROM session_sync_state WHERE id = 1
    `);

    if (!row) {
      return null;
    }

    return {
      lastSyncTime: row.last_sync_time,
      lastSyncVersion: row.last_sync_version,
      pendingOperations: JSON.parse(row.pending_operations || '[]')
    };
  }

  /**
   * 保存同步状态
   */
  async saveSyncState(state: SyncState): Promise<void> {
    await this.database.run(`
      INSERT OR REPLACE INTO session_sync_state (id, last_sync_time, last_sync_version, pending_operations, updated_at)
      VALUES (1, ?, ?, ?, ?)
    `, [
      state.lastSyncTime,
      state.lastSyncVersion,
      JSON.stringify(state.pendingOperations || []),
      Date.now()
    ]);
  }
}

/**
 * 后端部分 - 同步服务
 */
@Injectable()
export class SyncService {
  /**
   * 增量同步会话列表
   */
  async incrementalSync(userId: number, since: number, version: number): Promise<SyncResponse> {
    // 1. 查询指定时间之后更新的会话
    const sessions = await this.sessionRepository.getSessionsByUserIdSince(userId, since);

    // 2. 过滤版本号更高的会话
    const updatedSessions = sessions.filter(s => s.version > version);

    // 3. 计算更新数量
    const updatedCount = await this.sessionRepository.countUpdatedSessions(userId, since);

    return {
      sessions: updatedSessions,
      syncTime: Date.now(),
      syncVersion: this.getLatestSyncVersion(),
      updatedCount
    };
  }
}

/**
 * 前端部分(渲染进程) - 会话创建服务
 */
class SessionCreator {
  /**
   * 创建单聊会话
   */
  async createPrivateSession(toUserId: number): Promise<string> {
    // 1. 先检查本地是否已存在该会话
    const existingSession = await this.checkSessionExists(toUserId, SessionType.Private);

    if (existingSession) {
      console.log('会话已存在:', existingSession.sid);
      return existingSession.sid;
    }

    // 2. 请求服务端创建会话
    try {
      const response = await fetch('/api/sessions/private', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ toUserId })
      });

      if (!response.ok) {
        throw new Error(`创建会话失败: ${response.statusText}`);
      }

      const result = await response.json();

      // 3. 保存会话到本地
      await this.saveSessionToLocal(result.session);

      // 4. 更新本地会话Map
      this.sessions.set(result.session.sid, result.session);

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

      console.log('单聊会话创建成功:', result.session.sid);
      return result.session.sid;
    } catch (error) {
      console.error('创建单聊会话失败:', error);
      throw error;
    }
  }

  /**
   * 创建群聊会话
   */
  async createGroupSession(groupName: string, memberIds: number[]): Promise<string> {
    // 1. 请求服务端创建群聊
    try {
      const response = await fetch('/api/sessions/group', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          groupName,
          memberIds
        })
      });

      if (!response.ok) {
        throw new Error(`创建群聊失败: ${response.statusText}`);
      }

      const result = await response.json();

      // 2. 保存会话到本地
      await this.saveSessionToLocal(result.session);

      // 3. 更新本地会话Map
      this.sessions.set(result.session.sid, result.session);

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

      console.log('群聊会话创建成功:', result.session.sid);
      return result.session.sid;
    } catch (error) {
      console.error('创建群聊会话失败:', error);
      throw error;
    }
  }

  /**
   * 检查本地是否已存在会话
   */
  private async checkSessionExists(targetId: number, sessionType: SessionType): Promise<Session | null> {
    // 单聊：根据目标用户ID查找
    if (sessionType === SessionType.Private) {
      for (const session of this.sessions.values()) {
        if (session.sessionType === SessionType.Private && session.targetId === targetId) {
          return session;
        }
      }
    }

    return null;
  }
}

/**
 * 前端部分(渲染进程) - 消息发送服务（显式创建模式）
 */
class MessageSender {
  /**
   * 发送消息 - 显式创建会话模式
   * 必须先创建会话，才能发送消息
   */
  async sendMessage(sessionId: string, content: string, messageType: MessageType = MessageType.Text): Promise<void> {
    // 1. 检查会话是否存在
    const session = this.sessions.get(sessionId);
    if (!session) {
      throw new Error('会话不存在，请先创建会话');
    }

    // 2. 构造消息对象
    const message: MessageDTO = {
      fromId: getCurrentUserId(),
      toId: session.targetId,
      sessionId,
      content,
      type: messageType,
      timestamp: Date.now()
    };

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

      console.log('消息发送成功，消息ID:', result.messageId);
    } catch (error) {
      console.error('消息发送失败:', error);
      throw error;
    }
  }
}

/**
 * 后端部分 - 会话创建服务
 */
@Injectable()
export class SessionCreationService {
  constructor(
    private sessionService: SessionService,
    private sessionMembersRepository: SessionMembersRepository
  ) {}

  /**
   * 创建单聊会话
   */
  async createPrivateSession(dto: CreatePrivateSessionDTO): Promise<Session> {
    const currentUserId = getCurrentUserId();
    const { toUserId } = dto;

    // 1. 生成会话ID（小用户ID_大用户ID）
    const userIds = [currentUserId, toUserId].sort((a, b) => a - b);
    const sessionId = `${userIds[0]}_${userIds[1]}`;

    // 2. 检查会话是否已存在
    const existing = await this.sessionService.getSessionById(sessionId);
    if (existing) {
      throw new BadRequestException('会话已存在');
    }

    // 3. 保存会话基本信息
    await this.sessionService.createBaseSession({
      sessionId,
      sessionType: SessionType.Private
    });

    // 4. 保存单聊扩展信息
    await this.sessionService.createPrivateSessionExt({
      sessionId,
      userId1: userIds[0],
      userId2: userIds[1]
    });

    // 5. 创建会话成员（两个用户）
    await this.sessionService.createMember({
      sessionId,
      userId: currentUserId,
      role: MemberRole.Member
    });
    await this.sessionService.createMember({
      sessionId,
      userId: toUserId,
      role: MemberRole.Member
    });

    // 6. 获取完整的会话信息
    const session = await this.sessionService.getSessionById(sessionId);

    // 7. 推送新会话给所有参与者
    await this.sessionService.pushNewSession(session, [currentUserId, toUserId]);

    return session;
  }

  /**
   * 创建群聊会话
   */
  async createGroupSession(dto: CreateGroupSessionDTO): Promise<Session> {
    const currentUserId = getCurrentUserId();
    const { groupName, memberIds } = dto;

    // 1. 生成群聊会话ID（UUID）
    const sessionId = this.generateUUID();

    // 2. 保存会话基本信息
    await this.sessionService.createBaseSession({
      sessionId,
      sessionType: SessionType.Group
    });

    // 3. 保存群聊扩展信息
    await this.sessionService.createGroupSessionExt({
      sessionId,
      groupName,
      groupAvatar: '',
      announcement: '',
      maxMembers: 500,
      joinPermission: 1,
      messagePermission: 1
    });

    // 4. 创建会话成员
    const allMemberIds = [currentUserId, ...memberIds];
    for (let i = 0; i < allMemberIds.length; i++) {
      const userId = allMemberIds[i];
      const role = i === 0 ? MemberRole.Owner : MemberRole.Member;

      await this.sessionService.createMember({
        sessionId,
        userId,
        role
      });
    }

    // 5. 获取完整的会话信息
    const session = await this.sessionService.getSessionById(sessionId);

    // 6. 推送新会话给所有成员
    await this.sessionService.pushNewSession(session, allMemberIds);

    return session;
  }

  /**
   * 生成UUID
   */
  private generateUUID(): string {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
      const r = Math.random() * 16 | 0;
      const v = c === 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  }
}

/**
 * 后端部分 - 消息处理服务（显式创建模式）
 */
@Injectable()
export class MessageService {
  constructor(
    private messageRepository: MessageRepository,
    private sessionService: SessionService,
    private unreadService: UnreadService
  ) {}

  /**
   * 处理消息（会话ID必须存在）
   */
  async handleMessage(message: MessageDTO): Promise<void> {
    // 1. 验证会话ID是否存在
    if (!message.sessionId) {
      throw new BadRequestException('会话ID不能为空，请先创建会话');
    }

    // 2. 验证会话是否存在
    const session = await this.sessionService.getSessionById(message.sessionId);
    if (!session) {
      throw new BadRequestException('会话不存在');
    }

    // 3. 验证用户是否是会话成员
    const isMember = await this.sessionService.isUserInSession(message.sessionId, message.fromId);
    if (!isMember) {
      throw new BadRequestException('您不是该会话的成员');
    }

    // 4. 保存消息
    const savedMessage = await this.messageRepository.save({
      ...message
    });

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

    // 6. 增加接收方的未读数（群聊需要给所有成员增加未读数，除了发送方）
    if (session.sessionType === SessionType.Private) {
      // 单聊：只给接收方增加未读数
      await this.unreadService.incrementUnreadCount(message.sessionId, message.toId);
    } else {
      // 群聊：给所有成员增加未读数，除了发送方
      const members = await this.sessionService.getMembersBySessionId(message.sessionId);
      for (const member of members) {
        if (member.userId !== message.fromId) {
          await this.unreadService.incrementUnreadCount(message.sessionId, member.userId);
        }
      }
    }

    // 7. 推送消息给接收方
    await this.pushMessageToReceiver(savedMessage, session.sessionType);

    // 8. 推送会话更新给所有参与者
    await this.sessionService.pushSessionUpdate(message.sessionId);

    return savedMessage;
  }
}

/**
 * 前端部分(渲染进程) - WebSocket监听会话更新
 */
class SessionManager {
  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 'session_update':
          this.handleSessionUpdate(message.data);
          break;
        case 'new_session':
          this.handleNewSession(message.data);
          break;
        default:
          break;
      }
    };
  }

  /**
   * 处理会话更新事件
   */
  handleSessionUpdate(event: SessionUpdateEvent): void {
    const { sid, update } = event;

    const session = this.sessions.get(sid);

    if (session) {
      // 更新现有会话
      Object.assign(session, update);
      this.saveSessionToLocalDB(session);
      this.updateUI();
    } else {
      // 新增会话
      const newSession: Session = {
        sid,
        ...update,
        createdAt: Date.now()
      };
      this.sessions.set(sid, newSession);
      this.saveSessionToLocalDB(newSession);
      this.updateUI();
    }
  }

  /**
   * 保存单个会话到本地数据库
   */
  private async saveSessionToLocalDB(session: Session): Promise<void> {
    await window.ipcRenderer.invoke('sessions:save', session);
  }
}

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

  @SubscribeMessage('session_update')
  handleSessionUpdate(client: Socket, payload: SessionUpdateEvent): void {
    // 转发会话更新到渲染进程
    this.eventBus.emit('session_update', payload);
  }

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

/**
 * 后端部分 - 会话服务
 */
@Injectable()
export class SessionService {
  constructor(
    private sessionRepository: SessionRepository,
    private webSocketGateway: SessionWebSocketGateway
  ) {}

  /**
   * 推送会话更新给所有参与者
   */
  async pushSessionUpdate(sessionId: string): Promise<void> {
    // 1. 获取会话信息
    const session = await this.sessionRepository.getSessionById(sessionId);
    if (!session) {
      return;
    }

    // 2. 获取会话成员
    const members = await this.sessionMembersRepository.getMembersBySessionId(sessionId);

    // 3. 推送会话更新给所有成员
    for (const member of members) {
      this.webSocketGateway.sendToUser(member.userId, {
        type: 'session_update',
        data: {
          sid: session.sessionId,
          update: {
            lastMessageId: session.lastMessageId,
            lastMessageContent: session.lastMessageContent,
            lastMessageType: session.lastMessageType,
            lastMessageTime: session.lastMessageTime,
            unreadCount: member.unreadCount,
            isTop: member.isTop,
            isMuted: member.isMuted,
            serverVersion: session.version
          }
        }
      });
    }
  }
}

/**
 * 前端部分(渲染进程) - 标记已读
 */
class SessionManager {
  /**
   * 标记会话为已读
   */
  async markSessionAsRead(sid: string): Promise<void> {
    const session = this.sessions.get(sid);

    if (!session || session.unreadCount === 0) {
      return;
    }

    try {
      // 1. 请求服务端标记已读
      await fetch(`/api/sessions/${sid}/read`, {
        method: 'POST'
      });

      // 2. 服务端会推送会话更新，所以这里只需等待
      console.log('已发送标记已读请求');
    } catch (error) {
      console.error('标记已读失败:', error);
      // 网络错误时，先更新本地UI，等待下次同步
      session.unreadCount = 0;
      this.updateUI();
    }
  }
}

/**
 * 后端部分 - 未读数管理
 */
@Injectable()
export class UnreadService {
  /**
   * 增加未读数（收到新消息时调用）
   */
  async incrementUnreadCount(sessionId: string, userId: number): Promise<void> {
    // 1. 在session_members表中增加未读数
    await this.sessionMembersRepository.incrementUnreadCount(sessionId, userId);

    // 2. 如果用户删除了该会话，需要恢复会话
    await this.sessionMembersRepository.restoreForMember(sessionId, userId);

    // 推送会话更新
    await this.sessionService.pushSessionUpdate(sessionId);
  }

  /**
   * 清零未读数（标记已读时调用）
   */
  async markAsRead(sessionId: string, userId: number): Promise<void> {
    // 1. 在session_members表中清零未读数
    await this.sessionMembersRepository.resetUnreadCount(sessionId, userId);

    // 推送会话更新
    await this.sessionService.pushSessionUpdate(sessionId);
  }
}

/**
 * 前端部分(渲染进程) - 用户偏好管理
 */
class SessionManager {
  /**
   * 置顶会话
   */
  async toggleSessionTop(sid: string, isTop: boolean): Promise<void> {
    try {
      // 通过HTTP请求服务端更新置顶状态
      await fetch(`/api/sessions/${sid}/top`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ isTop })
      });

      console.log('置顶状态更新成功');
    } catch (error) {
      console.error('置顶失败:', error);
      throw error;
    }
    // 服务端会通过WebSocket推送会话更新，客户端接收后自动更新UI
  }

  /**
   * 静音会话
   */
  async toggleSessionMute(sid: string, isMuted: boolean): Promise<void> {
    try {
      // 通过HTTP请求服务端更新静音状态
      await fetch(`/api/sessions/${sid}/mute`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ isMuted })
      });

      console.log('静音状态更新成功');
    } catch (error) {
      console.error('静音失败:', error);
      throw error;
    }
    // 服务端会通过WebSocket推送会话更新，客户端接收后自动更新UI
  }
}

/**
 * 后端部分 - 会话偏好管理服务
 */
@Injectable()
export class SessionPreferenceService {
  constructor(
    private sessionMembersRepository: SessionMembersRepository,
    private sessionOperationLogsRepository: SessionOperationLogsRepository,
    private sessionService: SessionService
  ) {}

  /**
   * 切换置顶状态
   */
  async toggleSessionTop(sessionId: string, userId: number, isTop: boolean): Promise<void> {
    // 1. 更新会话成员的置顶状态
    await this.sessionMembersRepository.updateTopStatus(sessionId, userId, isTop);

    // 2. 保存操作日志
    await this.sessionOperationLogsRepository.save({
      sessionId,
      operatorId: userId,
      operationType: isTop ? 1 : 2,  // 1-置顶, 2-取消置顶
      operationTime: Date.now()
    });

    // 3. 推送会话更新给所有成员
    await this.sessionService.pushSessionUpdate(sessionId);
  }

  /**
   * 切换静音状态
   */
  async toggleSessionMute(sessionId: string, userId: number, isMuted: boolean): Promise<void> {
    // 1. 更新会话成员的静音状态
    await this.sessionMembersRepository.updateMuteStatus(sessionId, userId, isMuted);

    // 2. 保存操作日志
    await this.sessionOperationLogsRepository.save({
      sessionId,
      operatorId: userId,
      operationType: isMuted ? 3 : 4,  // 3-静音, 4-取消静音
      operationTime: Date.now()
    });

    // 3. 推送会话更新给所有成员
    await this.sessionService.pushSessionUpdate(sessionId);
  }
}

/**
 * 前端部分(渲染进程) - 会话删除
 */
class SessionManager {
  /**
   * 删除会话
   */
  async deleteSession(sid: string): Promise<void> {
    // 1. 请求服务端删除会话
    await fetch(`/api/sessions/${sid}`, {
      method: 'DELETE'
    });

    // 2. 从本地Map中移除
    const session = this.sessions.get(sid);
    if (session) {
      session.isDeleted = true;

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

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

      console.log('会话已删除');
    }
  }

  /**
   * 恢复已删除的会话
   */
  async restoreSession(sid: string): Promise<void> {
    // 1. 请求服务端恢复会话
    await fetch(`/api/sessions/${sid}/restore`, {
      method: 'POST'
    });

    // 2. 更新本地会话
    const session = this.sessions.get(sid);
    if (session) {
      session.isDeleted = false;

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

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

      console.log('会话已恢复');
    }
  }
}

/**
 * 后端部分 - 会话删除服务
 */
@Injectable()
export class SessionDeleteService {
  /**
   * 删除会话（软删除）
   */
  async deleteSession(sessionId: string, userId: number): Promise<void> {
    // 1. 在session_members表中设置is_deleted = true
    await this.sessionMembersRepository.markAsDeleted(sessionId, userId);

    // 2. 保存操作日志
    await this.sessionOperationLogsRepository.save({
      sessionId,
      operatorId: userId,
      operationType: 5,  // 5-删除
      operationTime: Date.now()
    });

    // 3. 推送会话更新
    await this.sessionService.pushSessionUpdate(sessionId);
  }

  /**
   * 恢复会话
   */
  async restoreSession(sessionId: string, userId: number): Promise<void> {
    // 1. 在session_members表中设置is_deleted = false
    await this.sessionMembersRepository.restoreMember(sessionId, userId);

    // 2. 保存操作日志
    await this.sessionOperationLogsRepository.save({
      sessionId,
      operatorId: userId,
      operationType: 6,  // 6-恢复删除
      operationTime: Date.now()
    });

    // 3. 推送会话更新
    await this.sessionService.pushSessionUpdate(sessionId);
  }
}

/**
 * 前端部分(渲染进程) - 离线同步
 */
class SessionManager {
  /**
   * 处理网络状态变化
   */
  handleNetworkChange(isOnline: boolean): void {
    this.isOnline = isOnline;

    if (isOnline) {
      // 网络恢复，执行离线同步
      this.syncOfflineData();
    }
  }

  /**
   * 同步离线数据
   */
  async syncOfflineData(): Promise<void> {
    // 1. 获取待同步的操作
    const pendingOperations = await this.loadPendingOperations();

    // 2. 执行同步
    await this.syncPendingOperations(pendingOperations);

    // 3. 从服务端拉取最新数据
    await this.syncSessionsFromServer();

    console.log('数据同步完成');
  }

  /**
   * 全量同步从服务端
   */
  private async fullSyncFromServer(): Promise<void> {
    try {
      // 请求服务端会话列表（全量）
      const response = await fetch('/api/sessions/fullSync');

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

      const data = await response.json();

      // 清空本地会话
      this.sessions.clear();

      // 更新本地会话
      for (const serverSession of data.sessions) {
        const session: Session = {
          sid: serverSession.sid,
          sessionType: serverSession.session_type,
          targetId: serverSession.target_id,
          targetName: serverSession.target_name,
          targetAvatar: serverSession.target_avatar,
          lastMessageId: serverSession.last_message_id,
          lastMessageContent: serverSession.last_message_content,
          lastMessageType: serverSession.last_message_type,
          lastMessageTime: serverSession.last_message_time,
          unreadCount: serverSession.unread_count,
          isTop: serverSession.is_top === 1,
          isMuted: serverSession.is_muted === 1,
          isDeleted: serverSession.is_deleted === 1,
          createdAt: serverSession.created_at,
          updatedAt: serverSession.updated_at,
          syncTime: Date.now(),
          serverVersion: serverSession.server_version
        };

        this.sessions.set(session.sid, session);
      }

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

      // 更新同步状态
      this.lastSyncTime = data.syncTime;
      this.lastSyncVersion = data.syncVersion;
      await this.saveSyncState();

      console.log(`全量同步完成：共 ${data.sessions.length} 个会话`);
    } catch (error) {
      console.error('全量同步失败:', error);
    }
  }

  /**
   * 同步待同步的操作
   */
  private async syncPendingOperations(operations: PendingOperation[]): Promise<void> {
    const failedOps: PendingOperation[] = [];
    const successOps: PendingOperation[] = [];

    for (const op of operations) {
      try {
        switch (op.type) {
          case 'top':
            await this.toggleSessionTop(op.sessionId, op.isTop);
            successOps.push(op);
            break;
          case 'mute':
            await this.toggleSessionMute(op.sessionId, op.isMuted);
            successOps.push(op);
            break;
          case 'delete':
            await this.deleteSession(op.sessionId);
            successOps.push(op);
            break;
        }
      } catch (error) {
        console.error(`同步操作失败 [${op.type}]:`, error);
        failedOps.push(op);
        // 重试策略：可以根据失败次数决定是否继续重试
        if (op.retryCount && op.retryCount > 3) {
          // 超过重试次数限制的操作
          console.error(`操作 ${op.sessionId} 超过最大重试次数，放弃同步`);
        } else {
          // 保留到待同步队列，下次上线继续重试
        }
      }
    }

    // 只清空成功同步的操作
    await window.ipcRenderer.invoke('syncState:savePendingOps', failedOps);
    
    console.log(`同步完成：成功 ${successOps.length} 个，失败 ${failedOps.length} 个`);
  }

  /**
   * 保存待同步的操作（离线时调用）
   */
  private async savePendingOperation(op: PendingOperation): Promise<void> {
    const pendingOps = await this.loadPendingOperations();
    pendingOps.push(op);
    await window.ipcRenderer.invoke('syncState:savePendingOps', pendingOps);
  }

  /**
   * 清空待同步的操作（用于同步完成后）
   */
  private async clearPendingOperations(): Promise<void> {
    await window.ipcRenderer.invoke('syncState:savePendingOps', []);
  }

  /**
   * 加载待同步的操作
   */
  private async loadPendingOperations(): Promise<PendingOperation[]> {
    const syncState = await this.loadSyncState();
    return syncState?.pendingOperations || [];
  }
}

/**
 * 后端部分 - 离线同步服务
 */
@Injectable()
export class SyncService {
  /**
   * 全量同步会话列表
   */
  async fullSync(userId: number): Promise<FullSyncResponse> {
    // 1. 查询用户的所有会话
    const sessions = await this.sessionRepository.getSessionsByUserId(userId);

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

    return {
      sessions,
      syncTime,
      syncVersion
    };
  }

  /**
   * 增量同步会话列表
   */
  async incrementalSync(userId: number, since: number, version: number): Promise<SyncResponse> {
    // 1. 查询指定时间之后更新的会话
    const sessions = await this.sessionRepository.getSessionsByUserIdSince(userId, since);

    // 2. 过滤版本号更高的会话
    const updatedSessions = sessions.filter(s => s.version > version);

    // 3. 计算更新数量
    const updatedCount = await this.sessionRepository.countUpdatedSessions(userId, since);

    return {
      sessions: updatedSessions,
      syncTime: Date.now(),
      syncVersion: this.getLatestSyncVersion(),
      updatedCount
    };
  }

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