nl-im-service/internal/service/room_service.go

/**
 * package service
 * 作用：房间管理服务
 */
package service

import (
	"fmt"
	"time"
	"xk-websocket-v2/internal/model"
	"xk-websocket-v2/internal/utils"

	"gorm.io/gorm"
)

// RoomService 房间服务结构体
type RoomService struct {
	DB *gorm.DB
}

// RoomSvc 全局单例
var RoomSvc *RoomService

/**
 * InitRoomService
 * 功能：初始化房间服务
 */
func InitRoomService(db *gorm.DB) {
	RoomSvc = &RoomService{DB: db}
}

/**
 * GenerateP2PRoomID
 * 功能：生成点对点聊天房间ID
 * 规则：将两个用户ID按字母序排序后，用下划线连接
 */
func GenerateP2PRoomID(userID1, userID2 string) string {
	if userID1 < userID2 {
		return fmt.Sprintf("%s_%s", userID1, userID2)
	}
	return fmt.Sprintf("%s_%s", userID2, userID1)
}

/**
 * GenerateGroupRoomID
 * 功能：生成群聊房间ID
 * 规则：使用雪花ID生成全局唯一ID
 */
func GenerateGroupRoomID() string {
	id, err := utils.NextID()
	if err != nil {
		// 如果雪花ID生成失败，使用备用方案
		return fmt.Sprintf("group_%d", time.Now().UnixNano())
	}
	return fmt.Sprintf("group_%d", id)
}

/**
 * CreateRoom
 * 功能：创建房间
 */
func (s *RoomService) CreateRoom(roomType string, members []string, creatorID string) (*model.ChatRoom, error) {
	var roomID string
	var ownerID string = "0" // 单聊默认为0
	
	if roomType == "p2p" {
		if len(members) != 2 {
			return nil, fmt.Errorf("点对点房间需要2个成员")
		}
		roomID = GenerateP2PRoomID(members[0], members[1])
	} else {
		roomID = GenerateGroupRoomID()
		// 群聊时，创建者就是群主
		ownerID = creatorID
	}

	// 检查房间是否已存在
	var existingRoom model.ChatRoom
	if err := s.DB.Where("room_id = ?", roomID).First(&existingRoom).Error; err == nil {
		return &existingRoom, nil
	}

	// 开始事务
	tx := s.DB.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 创建房间
	room := model.ChatRoom{
		RoomID:    roomID,
		RoomType:   roomType,
		OwnerID:   ownerID,
		CreatorID: creatorID,
	}

	if roomType == "group" {
		room.RoomName = "群聊"
	}

	if err := tx.Create(&room).Error; err != nil {
		tx.Rollback()
		return nil, err
	}

	// 创建房间成员记录
	for _, userID := range members {
		member := model.RoomMember{
			RoomID: roomID,
			UserID: userID,
		}
		if err := tx.Create(&member).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
	}

	if err := tx.Commit().Error; err != nil {
		return nil, err
	}

	return &room, nil
}

/**
 * GetRoom
 * 功能：获取房间信息
 */
func (s *RoomService) GetRoom(roomID string) (*model.ChatRoom, error) {
	var room model.ChatRoom
	result := s.DB.Where("room_id = ?", roomID).First(&room)
	if result.Error != nil {
		return nil, result.Error
	}
	return &room, nil
}

/**
 * GetOrCreateP2PRoom
 * 功能：获取或创建点对点房间
 */
func (s *RoomService) GetOrCreateP2PRoom(userID1, userID2 string) (*model.ChatRoom, error) {
	roomID := GenerateP2PRoomID(userID1, userID2)

	// 尝试获取现有房间
	var room model.ChatRoom
	if err := s.DB.Where("room_id = ?", roomID).First(&room).Error; err == nil {
		return &room, nil
	}

	// 创建新房间
	members := []string{userID1, userID2}
	return s.CreateRoom("p2p", members, userID1)
}

/**
 * UpdateRoomLastMessage
 * 功能：更新房间最后消息
 */
func (s *RoomService) UpdateRoomLastMessage(roomID, message string) error {
	now := time.Now()
	return s.DB.Model(&model.ChatRoom{}).
		Where("room_id = ?", roomID).
		Updates(map[string]interface{}{
			"last_message":      message,
			"last_message_time": now,
		}).Error
}

/**
 * GetRoomMembers
 * 功能：获取房间成员列表
 */
func (s *RoomService) GetRoomMembers(roomID string) ([]string, error) {
	var members []model.RoomMember
	if err := s.DB.Where("room_id = ?", roomID).Find(&members).Error; err != nil {
		return nil, err
	}
	
	userIDs := make([]string, len(members))
	for i, member := range members {
		userIDs[i] = member.UserID
	}
	return userIDs, nil
}

/**
 * AddRoomMember
 * 功能：添加房间成员
 */
func (s *RoomService) AddRoomMember(roomID, userID string) error {
	member := model.RoomMember{
		RoomID: roomID,
		UserID: userID,
	}
	return s.DB.Create(&member).Error
}

/**
 * RemoveRoomMember
 * 功能：移除房间成员
 */
func (s *RoomService) RemoveRoomMember(roomID, userID string) error {
	return s.DB.Where("room_id = ? AND user_id = ?", roomID, userID).
		Delete(&model.RoomMember{}).Error
}