jiang13-bbs/backend/service/chat.go

// Package service 群聊业务（二期）。
//
// 铁律：消息先落库再由 handler 经 WS 广播，WS 不承担可靠投递；
// 未读数以成员行 last_read_message_id 为水位做 SQL 对账，离线期间不丢消息。
package service

import (
	"errors"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/freefire/jiang13-bbs/model"
	"gorm.io/gorm"
)

var (
	ErrChatNotFound        = errors.New("会话不存在")
	ErrChatNotMember       = errors.New("不是会话成员")
	ErrChatNameInvalid     = errors.New("群名称需为 2-32 个字符")
	ErrChatDescInvalid     = errors.New("群简介不能超过 200 个字符")
	ErrChatContentEmpty    = errors.New("消息内容不能为空")
	ErrChatContentTooLong  = errors.New("单条消息不能超过 2000 个字符")
	ErrChatMuted           = errors.New("你已被群主禁言")
	ErrChatOwnerOnly       = errors.New("仅群主可执行该操作")
	ErrChatOwnerLeave      = errors.New("群主不能直接退出，请先解散该群")
	ErrChatPrivateInvite   = errors.New("私密群需邀请才能加入")
	ErrChatDefaultLeave    = errors.New("默认大厅不可退出")
	ErrChatDefaultDissolve = errors.New("默认大厅不可解散")
	ErrChatRecallDenied    = errors.New("无权撤回该消息")
	ErrChatMsgNotFound     = errors.New("消息不存在")
	ErrChatDMSelf          = errors.New("不能与自己私聊")
	ErrChatDMDissolve      = errors.New("私聊会话不可解散")
	ErrChatUserGone        = errors.New("用户不存在或已封禁")
	ErrChatHallPinFixed    = errors.New("大厅已置顶且不可取消")
	ErrChatSiteOwnerOnly   = errors.New("仅站长可任命群管理员")
	ErrChatInvalidRole     = errors.New("无效的群成员角色")
	ErrChatMuteDenied      = errors.New("无权禁言该成员")
	ErrChatCannotMuteOwner = errors.New("不能禁言群主或站长")
	ErrChatAdminAccess     = errors.New("无权管理消息")
)

// CanOverseeChat 站长/超管可旁路查看全部群（含私聊）并撤回任意消息
func CanOverseeChat(role model.Role) bool {
	return role == model.RoleOwner || role == model.RoleSuperAdmin
}

const (
	chatNameMinRune = 2
	chatNameMaxRune = 32
	chatDescMaxRune = 200
	chatMsgMaxRune  = 2000
	chatMentionMax  = 20
)

// chatMentionRe @提醒匹配：用户名 3-32 位字母/数字/下划线/连字符；
// 是否有效最终以"群成员精确匹配"为准，名单外的 @ 原样当普通文本
var chatMentionRe = regexp.MustCompile(`@([A-Za-z0-9_-]{3,32})`)

// ChatService 群聊服务
type ChatService struct {
	db    *gorm.DB
	notif *NotificationService
}

func NewChatService(db *gorm.DB, notif *NotificationService) *ChatService {
	return &ChatService{db: db, notif: notif}
}

// RoomView 会话列表/详情聚合视图
type RoomView struct {
	model.ChatRoom
	Joined      bool        `json:"joined"`
	MyRole      string      `json:"my_role"`
	UnreadCount int64       `json:"unread_count"`
	Pinned      bool        `json:"pinned"`      // 对当前用户是否置顶（含大厅强制）
	PinForced   bool        `json:"pin_forced"`  // 大厅强制置顶，不可取消
	Peer        *model.User `json:"peer,omitempty"` // 私聊对方（仅 direct）
}

// UnreadRoom 单个会话的未读计数
type UnreadRoom struct {
	RoomID uint  `gorm:"column:room_id" json:"room_id"`
	Count  int64 `gorm:"column:cnt" json:"count"`
}

func directKey(a, b uint) string {
	if a > b {
		a, b = b, a
	}
	return strconv.FormatUint(uint64(a), 10) + ":" + strconv.FormatUint(uint64(b), 10)
}

func (s *ChatService) getRoom(roomID uint) (*model.ChatRoom, error) {
	var room model.ChatRoom
	err := s.db.First(&room, roomID).Error
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, ErrChatNotFound
	}
	if err != nil {
		return nil, err
	}
	return &room, nil
}

func (s *ChatService) membership(tx *gorm.DB, roomID, userID uint) (*model.ChatRoomMember, error) {
	var m model.ChatRoomMember
	err := tx.Where("room_id = ? AND user_id = ?", roomID, userID).First(&m).Error
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, ErrChatNotMember
	}
	if err != nil {
		return nil, err
	}
	return &m, nil
}

// Membership 供 WS 握手后动态订阅房间鉴权
func (s *ChatService) Membership(roomID, userID uint) (*model.ChatRoomMember, error) {
	return s.membership(s.db, roomID, userID)
}

// unreadCounts 批量计算访问者在给定群集合中的未读数（消息 ID 大于已读水位、且排除本人发送）
func (s *ChatService) unreadCounts(userID uint, roomIDs []uint) map[uint]int64 {
	out := make(map[uint]int64)
	if userID == 0 || len(roomIDs) == 0 {
		return out
	}
	var rows []UnreadRoom
	s.db.Table("chat_messages AS m").
		Select("m.room_id AS room_id, count(*) AS cnt").
		Joins("JOIN chat_room_members AS rm ON rm.room_id = m.room_id AND rm.user_id = ?", userID).
		Where("m.room_id IN ? AND m.id > rm.last_read_message_id AND m.sender_id <> ? AND m.deleted_at IS NULL AND m.recalled_at IS NULL", roomIDs, userID).
		Group("m.room_id").
		Scan(&rows)
	for _, r := range rows {
		out[r.RoomID] = r.Count
	}
	return out
}

// toViews 批量填充 joined/角色/未读（避免 N+1）
func (s *ChatService) toViews(rooms []model.ChatRoom, userID uint) []RoomView {
	ids := make([]uint, 0, len(rooms))
	for i := range rooms {
		ids = append(ids, rooms[i].ID)
	}
	memberMap := make(map[uint]model.ChatRoomMember)
	if userID != 0 && len(ids) > 0 {
		var ms []model.ChatRoomMember
		s.db.Where("user_id = ? AND room_id IN ?", userID, ids).Find(&ms)
		for _, m := range ms {
			memberMap[m.RoomID] = m
		}
	}
	unread := s.unreadCounts(userID, ids)
	views := make([]RoomView, 0, len(rooms))
	for _, r := range rooms {
		// 会话列表预览不向前台下发已撤回正文
		if r.LastMessage != nil && r.LastMessage.RecalledAt != nil {
			r.LastMessage.Content = ""
		}
		v := RoomView{ChatRoom: r, UnreadCount: unread[r.ID]}
		if r.IsDefault {
			v.Pinned = true
			v.PinForced = true
		}
		if m, ok := memberMap[r.ID]; ok {
			v.Joined = true
			v.MyRole = m.Role
			if m.PinnedAt != nil {
				v.Pinned = true
			}
		}
		views = append(views, v)
	}
	s.attachPeers(views, userID)
	sortRoomViews(views, memberMap)
	return views
}

// sortRoomViews：大厅强制置顶 > 个人置顶(pinned_at DESC) > last_message_id DESC
func sortRoomViews(views []RoomView, memberMap map[uint]model.ChatRoomMember) {
	sort.SliceStable(views, func(i, j int) bool {
		a, b := views[i], views[j]
		if a.IsDefault != b.IsDefault {
			return a.IsDefault
		}
		aPin, bPin := !a.IsDefault && a.Pinned, !b.IsDefault && b.Pinned
		if aPin != bPin {
			return aPin
		}
		if aPin && bPin {
			var at, bt time.Time
			if m, ok := memberMap[a.ID]; ok && m.PinnedAt != nil {
				at = *m.PinnedAt
			}
			if m, ok := memberMap[b.ID]; ok && m.PinnedAt != nil {
				bt = *m.PinnedAt
			}
			if !at.Equal(bt) {
				return at.After(bt)
			}
		}
		if a.LastMessageID != b.LastMessageID {
			return a.LastMessageID > b.LastMessageID
		}
		return a.ID > b.ID
	})
}

// attachPeers 为私聊会话填充对方用户信息
func (s *ChatService) attachPeers(views []RoomView, viewerID uint) {
	directIDs := make([]uint, 0)
	for i := range views {
		if views[i].RoomType == model.ChatRoomTypeDirect {
			directIDs = append(directIDs, views[i].ID)
		}
	}
	if len(directIDs) == 0 {
		return
	}
	var members []model.ChatRoomMember
	s.db.Where("room_id IN ? AND user_id <> ?", directIDs, viewerID).Preload("User").Preload("User.Badges.Badge").Find(&members)
	peerByRoom := make(map[uint]*model.User, len(members))
	for i := range members {
		u := members[i].User
		peerByRoom[members[i].RoomID] = &u
	}
	for i := range views {
		if p, ok := peerByRoom[views[i].ID]; ok {
			views[i].Peer = p
			if views[i].Name == "" && p != nil {
				views[i].Name = p.Nickname
				if views[i].Name == "" {
					views[i].Name = p.Username
				}
			}
		}
	}
}

// CreateRoom 建群：任意登录用户可建；isPrivate 时仅邀请可进；memberIDs 为初始成员（不含创建者）
func (s *ChatService) CreateRoom(creatorID uint, name, description string, isPrivate bool, memberIDs []uint) (*RoomView, error) {
	name = strings.TrimSpace(name)
	description = strings.TrimSpace(description)
	if l := len([]rune(name)); l < chatNameMinRune || l > chatNameMaxRune {
		return nil, ErrChatNameInvalid
	}
	if len([]rune(description)) > chatDescMaxRune {
		return nil, ErrChatDescInvalid
	}
	// 去重、排除自己
	seen := map[uint]struct{}{creatorID: {}}
	cleanIDs := make([]uint, 0, len(memberIDs))
	for _, id := range memberIDs {
		if id == 0 {
			continue
		}
		if _, ok := seen[id]; ok {
			continue
		}
		seen[id] = struct{}{}
		cleanIDs = append(cleanIDs, id)
	}
	room := model.ChatRoom{
		Name:        name,
		Description: description,
		OwnerID:     creatorID,
		RoomType:    model.ChatRoomTypeGroup,
		IsPrivate:   isPrivate,
		MemberCount: 1 + len(cleanIDs),
	}
	err := s.db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(&room).Error; err != nil {
			return err
		}
		m := model.ChatRoomMember{RoomID: room.ID, UserID: creatorID, Role: model.ChatRoleOwner}
		if err := tx.Create(&m).Error; err != nil {
			return err
		}
		for _, uid := range cleanIDs {
			mm := model.ChatRoomMember{RoomID: room.ID, UserID: uid, Role: model.ChatRoleMember}
			if err := tx.Create(&mm).Error; err != nil {
				return err
			}
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	var full model.ChatRoom
	if err := s.db.Preload("Owner").First(&full, room.ID).Error; err != nil {
		return nil, err
	}
	v := RoomView{ChatRoom: full, Joined: true, MyRole: model.ChatRoleOwner}
	return &v, nil
}

// ListRooms 会话列表。joinedOnly=true 时仅已加入（IM 侧栏）；否则公开群 + 已加入私密（站长旁路可见全部）
func (s *ChatService) ListRooms(userID uint, oversee, joinedOnly bool, q string, page, size int) ([]RoomView, int64, error) {
	if page < 1 {
		page = 1
	}
	if size < 1 || size > 50 {
		size = 20
	}
	query := s.db.Model(&model.ChatRoom{})
	if joinedOnly && userID > 0 {
		query = query.Where("id IN (SELECT room_id FROM chat_room_members WHERE user_id = ?)", userID)
	} else if !oversee {
		if userID == 0 {
			query = query.Where("is_private = ? AND room_type = ?", false, model.ChatRoomTypeGroup)
		} else {
			query = query.Where(
				"(is_private = ? AND room_type = ?) OR id IN (SELECT room_id FROM chat_room_members WHERE user_id = ?)",
				false, model.ChatRoomTypeGroup, userID,
			)
		}
	}
	if q = strings.TrimSpace(q); q != "" {
		esc := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(q)
		query = query.Where(`name ILIKE ? ESCAPE '\'`, "%"+esc+"%")
	}
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	var rooms []model.ChatRoom
	// 已加入列表需按个人置顶排序：先全量取出再内存排序分页（会话量通常很小）
	if joinedOnly && userID > 0 {
		if err := query.
			Preload("Owner").Preload("LastMessage.Sender").
			Find(&rooms).Error; err != nil {
			return nil, 0, err
		}
		views := s.toViews(rooms, userID)
		start := (page - 1) * size
		if start >= len(views) {
			return []RoomView{}, total, nil
		}
		end := start + size
		if end > len(views) {
			end = len(views)
		}
		return views[start:end], total, nil
	}
	if err := query.
		Order("is_default DESC, last_message_id DESC, id DESC").
		Offset((page - 1) * size).Limit(size).
		Preload("Owner").Preload("LastMessage.Sender").
		Find(&rooms).Error; err != nil {
		return nil, 0, err
	}
	return s.toViews(rooms, userID), total, nil
}

// SetRoomPinned 当前用户置顶/取消置顶（大厅强制置顶不可取消）
func (s *ChatService) SetRoomPinned(userID, roomID uint, pinned bool) (*RoomView, error) {
	room, err := s.getRoom(roomID)
	if err != nil {
		return nil, err
	}
	if room.IsDefault {
		return nil, ErrChatHallPinFixed
	}
	m, err := s.membership(s.db, roomID, userID)
	if err != nil {
		return nil, err
	}
	if pinned {
		now := time.Now()
		if err := s.db.Model(m).Update("pinned_at", now).Error; err != nil {
			return nil, err
		}
	} else {
		if err := s.db.Model(m).Update("pinned_at", nil).Error; err != nil {
			return nil, err
		}
	}
	return s.RoomDetail(userID, roomID, false)
}

// GetOrCreateDM 获取或创建与对方的一对一私聊（幂等）
func (s *ChatService) GetOrCreateDM(meID, peerID uint) (*RoomView, error) {
	if peerID == 0 || peerID == meID {
		return nil, ErrChatDMSelf
	}
	var peer model.User
	if err := s.db.Where("id = ? AND banned = ? AND deleted_at IS NULL", peerID, false).First(&peer).Error; err != nil {
		return nil, ErrChatUserGone
	}
	key := directKey(meID, peerID)
	var existing model.ChatRoom
	err := s.db.Where("room_type = ? AND direct_key = ?", model.ChatRoomTypeDirect, key).First(&existing).Error
	if err == nil {
		// 关闭私聊会硬删成员行、丢失已读水位；主动重开视为已读历史，
		// 否则重建行 last_read=0 会把全部历史消息重算成未读（列表徽标闪现）
		_ = s.ensureMember(existing.ID, meID, existing.LastMessageID)
		_ = s.ensureMember(existing.ID, peerID)
		return s.RoomDetail(meID, existing.ID, false)
	}
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, err
	}
	room := model.ChatRoom{
		Name:        "",
		OwnerID:     meID,
		RoomType:    model.ChatRoomTypeDirect,
		DirectKey:   key,
		IsPrivate:   true,
		MemberCount: 2,
	}
	err = s.db.Transaction(func(tx *gorm.DB) error {
		if e := tx.Create(&room).Error; e != nil {
			return e
		}
		ms := []model.ChatRoomMember{
			{RoomID: room.ID, UserID: meID, Role: model.ChatRoleMember},
			{RoomID: room.ID, UserID: peerID, Role: model.ChatRoleMember},
		}
		return tx.Create(&ms).Error
	})
	if err != nil {
		if e2 := s.db.Where("room_type = ? AND direct_key = ?", model.ChatRoomTypeDirect, key).First(&existing).Error; e2 == nil {
			return s.RoomDetail(meID, existing.ID, false)
		}
		return nil, err
	}
	return s.RoomDetail(meID, room.ID, false)
}

// ensureMember 保证成员行存在；重建（如私聊关闭后重开）时可选恢复已读水位
func (s *ChatService) ensureMember(roomID, userID uint, readWatermark ...uint) error {
	_, err := s.membership(s.db, roomID, userID)
	if err == nil {
		return nil
	}
	if !errors.Is(err, ErrChatNotMember) {
		return err
	}
	m := model.ChatRoomMember{RoomID: roomID, UserID: userID, Role: model.ChatRoleMember}
	if len(readWatermark) > 0 {
		m.LastReadMessageID = readWatermark[0]
	}
	if e := s.db.Create(&m).Error; e != nil {
		return e
	}
	return s.db.Model(&model.ChatRoom{}).Where("id = ?", roomID).
		UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
}

// ListMemberIDs 房间全部成员 ID（发消息后推未读角标用）
func (s *ChatService) ListMemberIDs(roomID uint) ([]uint, error) {
	var ids []uint
	err := s.db.Model(&model.ChatRoomMember{}).Where("room_id = ?", roomID).Pluck("user_id", &ids).Error
	return ids, err
}

// SearchUsersForChat 按用户名/昵称搜索可发起私聊的用户（排除自己、封禁）
func (s *ChatService) SearchUsersForChat(meID uint, q string, limit int) ([]model.User, error) {
	q = strings.TrimSpace(q)
	if q == "" {
		return nil, nil
	}
	if limit < 1 || limit > 20 {
		limit = 10
	}
	esc := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(q)
	like := "%" + esc + "%"
	var users []model.User
	err := s.db.Select("id", "username", "nickname", "avatar", "role").
		Where("id <> ? AND banned = ? AND deleted_at IS NULL AND (username ILIKE ? ESCAPE '\\' OR nickname ILIKE ? ESCAPE '\\')",
			meID, false, like, like).
		Order("username ASC").Limit(limit).Find(&users).Error
	return users, err
}

// RoomDetail 群详情：成员或监管者可读；公开非成员返回 joined=false（可预览元数据）
func (s *ChatService) RoomDetail(userID, roomID uint, oversee bool) (*RoomView, error) {
	room, err := s.getRoom(roomID)
	if err != nil {
		return nil, err
	}
	_, memErr := s.membership(s.db, roomID, userID)
	isMember := memErr == nil
	if !isMember && !oversee {
		if room.IsPrivate {
			return nil, ErrChatNotFound // 私密非成员伪装不存在
		}
		// 公开非成员：允许预览
	} else if memErr != nil && !oversee && !errors.Is(memErr, ErrChatNotMember) {
		return nil, memErr
	}
	if err := s.db.Preload("Owner").Preload("LastMessage.Sender").First(room, roomID).Error; err != nil {
		return nil, err
	}
	views := s.toViews([]model.ChatRoom{*room}, userID)
	v := views[0]
	if oversee && !v.Joined {
		v.Joined = true // 监管旁路按已加入展示，可看历史
		v.MyRole = "overseer"
	}
	return &v, nil
}

// Join 加入公开群（私密/私聊拒绝；幂等）
func (s *ChatService) Join(userID, roomID uint) (member *model.ChatRoomMember, joined bool, err error) {
	room, err := s.getRoom(roomID)
	if err != nil {
		return nil, false, err
	}
	if room.RoomType == model.ChatRoomTypeDirect {
		return nil, false, ErrChatNotFound
	}
	if room.IsPrivate {
		return nil, false, ErrChatPrivateInvite
	}
	if m, mErr := s.membership(s.db, roomID, userID); mErr == nil {
		return m, false, nil
	} else if !errors.Is(mErr, ErrChatNotMember) {
		return nil, false, mErr
	}
	m := model.ChatRoomMember{RoomID: roomID, UserID: userID, Role: model.ChatRoleMember}
	err = s.db.Transaction(func(tx *gorm.DB) error {
		if e := tx.Create(&m).Error; e != nil {
			return e
		}
		return tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
			UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
	})
	if err != nil {
		if existing, qErr := s.membership(s.db, roomID, userID); qErr == nil {
			return existing, false, nil
		}
		return nil, false, err
	}
	return &m, true, nil
}

// InviteMembers 群主/群管（或监管）拉人入群；返回实际新加入的用户 ID
func (s *ChatService) InviteMembers(operatorID, roomID uint, userIDs []uint, oversee bool) ([]uint, error) {
	room, err := s.getRoom(roomID)
	if err != nil {
		return nil, err
	}
	if room.RoomType == model.ChatRoomTypeDirect {
		return nil, ErrChatOwnerOnly
	}
	if !oversee {
		op, err := s.membership(s.db, roomID, operatorID)
		if err != nil {
			return nil, err
		}
		if op.Role != model.ChatRoleOwner && op.Role != model.ChatRoleAdmin {
			return nil, ErrChatOwnerOnly
		}
	}
	added := make([]uint, 0)
	for _, uid := range userIDs {
		if uid == 0 {
			continue
		}
		if _, mErr := s.membership(s.db, roomID, uid); mErr == nil {
			continue
		}
		var u model.User
		if err := s.db.Select("id").Where("id = ? AND banned = ? AND deleted_at IS NULL", uid, false).First(&u).Error; err != nil {
			continue
		}
		m := model.ChatRoomMember{RoomID: roomID, UserID: uid, Role: model.ChatRoleMember}
		if room.OwnerID == uid {
			m.Role = model.ChatRoleOwner
		}
		err := s.db.Transaction(func(tx *gorm.DB) error {
			if e := tx.Create(&m).Error; e != nil {
				return e
			}
			return tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
				UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
		})
		if err == nil {
			added = append(added, uid)
		}
	}
	return added, nil
}

// EnsureDefaultMembership 将用户加入默认大厅（注册后调用，幂等）
func (s *ChatService) EnsureDefaultMembership(userID uint) error {
	var room model.ChatRoom
	if err := s.db.Where("is_default = ?", true).First(&room).Error; err != nil {
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}
		// 空库首次部署时启动播种因无用户跳过，这里就地补建大厅（自愈，不依赖重启）
		if err := model.EnsureDefaultChatRoom(s.db); err != nil {
			return err
		}
		if err := s.db.Where("is_default = ?", true).First(&room).Error; err != nil {
			return nil // 仍无大厅（尚无任何用户）则跳过
		}
	}
	if _, err := s.membership(s.db, room.ID, userID); err == nil {
		return nil
	}
	m := model.ChatRoomMember{RoomID: room.ID, UserID: userID, Role: model.ChatRoleMember}
	return s.db.Transaction(func(tx *gorm.DB) error {
		if e := tx.Create(&m).Error; e != nil {
			return e
		}
		return tx.Model(&model.ChatRoom{}).Where("id = ?", room.ID).
			UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
	})
}

// Leave 普通成员退出群聊（群主不可退出；默认大厅不可退出；私聊可退出）
func (s *ChatService) Leave(userID, roomID uint) error {
	room, err := s.getRoom(roomID)
	if err != nil {
		return err
	}
	if room.IsDefault {
		return ErrChatDefaultLeave
	}
	m, err := s.membership(s.db, roomID, userID)
	if err != nil {
		return err
	}
	if room.RoomType != model.ChatRoomTypeDirect && m.Role == model.ChatRoleOwner {
		return ErrChatOwnerLeave
	}
	return s.removeMember(roomID, userID)
}

// removeMember 删除成员行并把群人数 -1（不小于 0）
func (s *ChatService) removeMember(roomID, userID uint) error {
	return s.db.Transaction(func(tx *gorm.DB) error {
		res := tx.Where("room_id = ? AND user_id = ?", roomID, userID).Delete(&model.ChatRoomMember{})
		if res.Error != nil {
			return res.Error
		}
		if res.RowsAffected == 0 {
			return nil
		}
		return tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
			UpdateColumn("member_count", gorm.Expr("GREATEST(member_count - 1, 0)")).Error
	})
}

// Dissolve 群主解散群（默认大厅/私聊不可解散）
func (s *ChatService) Dissolve(userID, roomID uint, oversee bool) error {
	room, err := s.getRoom(roomID)
	if err != nil {
		return err
	}
	if room.IsDefault {
		return ErrChatDefaultDissolve
	}
	if room.RoomType == model.ChatRoomTypeDirect {
		return ErrChatDMDissolve
	}
	if !oversee {
		m, err := s.membership(s.db, roomID, userID)
		if err != nil {
			return err
		}
		if m.Role != model.ChatRoleOwner {
			return ErrChatOwnerOnly
		}
	}
	return s.db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Delete(&model.ChatRoom{}, roomID).Error; err != nil {
			return err
		}
		return tx.Where("room_id = ?", roomID).Delete(&model.ChatRoomMember{}).Error
	})
}

// UpdateRoom 群主修改群名称/简介
func (s *ChatService) UpdateRoom(userID, roomID uint, name, description string) (*model.ChatRoom, error) {
	name = strings.TrimSpace(name)
	description = strings.TrimSpace(description)
	if l := len([]rune(name)); l < chatNameMinRune || l > chatNameMaxRune {
		return nil, ErrChatNameInvalid
	}
	if len([]rune(description)) > chatDescMaxRune {
		return nil, ErrChatDescInvalid
	}
	room, err := s.getRoom(roomID)
	if err != nil {
		return nil, err
	}
	m, err := s.membership(s.db, roomID, userID)
	if err != nil {
		return nil, err
	}
	if m.Role != model.ChatRoleOwner {
		return nil, ErrChatOwnerOnly
	}
	if err := s.db.Model(room).Updates(map[string]interface{}{
		"name":        name,
		"description": description,
	}).Error; err != nil {
		return nil, err
	}
	return s.getRoom(roomID)
}

// ListMembers 成员名单：成员或监管者可查看
func (s *ChatService) ListMembers(userID, roomID uint, oversee bool) ([]model.ChatRoomMember, error) {
	if _, err := s.getRoom(roomID); err != nil {
		return nil, err
	}
	if !oversee {
		if _, err := s.membership(s.db, roomID, userID); err != nil {
			return nil, err
		}
	}
	var list []model.ChatRoomMember
	err := s.db.Where("room_id = ?", roomID).
		Order("CASE WHEN role = 'owner' THEN 0 WHEN role = 'admin' THEN 1 ELSE 2 END, created_at ASC").
		Preload("User").Preload("User.Badges.Badge").
		Find(&list).Error
	if err != nil {
		return nil, err
	}
	return list, nil
}

// Kick 群主/群管/全站监管踢人（不能踢群主；群管不能踢其他群管）
func (s *ChatService) Kick(operatorID, roomID, targetID uint, oversee bool) error {
	if _, err := s.getRoom(roomID); err != nil {
		return err
	}
	target, err := s.membership(s.db, roomID, targetID)
	if err != nil {
		return err
	}
	if target.Role == model.ChatRoleOwner {
		return ErrChatOwnerOnly
	}
	if !oversee {
		op, err := s.membership(s.db, roomID, operatorID)
		if err != nil {
			return err
		}
		if op.Role != model.ChatRoleOwner && op.Role != model.ChatRoleAdmin {
			return ErrChatOwnerOnly
		}
		if target.Role == model.ChatRoleAdmin && op.Role != model.ChatRoleOwner {
			return ErrChatOwnerOnly
		}
	}
	return s.removeMember(roomID, targetID)
}

// SetMemberMute 禁言/解禁：群主、群管、全站监管；不可禁言群主或站点站长账号
func (s *ChatService) SetMemberMute(operatorID, roomID, targetID uint, muted, oversee bool) error {
	room, err := s.getRoom(roomID)
	if err != nil {
		return err
	}
	if room.RoomType == model.ChatRoomTypeDirect {
		return ErrChatOwnerOnly
	}
	target, err := s.membership(s.db, roomID, targetID)
	if err != nil {
		return err
	}
	if target.Role == model.ChatRoleOwner {
		return ErrChatCannotMuteOwner
	}
	var targetUser model.User
	if err := s.db.Select("role").First(&targetUser, targetID).Error; err != nil {
		return ErrChatUserGone
	}
	if targetUser.Role == model.RoleOwner {
		return ErrChatCannotMuteOwner
	}
	if !oversee {
		op, err := s.membership(s.db, roomID, operatorID)
		if err != nil {
			return err
		}
		if op.Role != model.ChatRoleOwner && op.Role != model.ChatRoleAdmin {
			return ErrChatMuteDenied
		}
		if target.Role == model.ChatRoleAdmin && op.Role != model.ChatRoleOwner {
			return ErrChatMuteDenied
		}
	}
	return s.db.Model(&model.ChatRoomMember{}).
		Where("room_id = ? AND user_id = ?", roomID, targetID).
		Select("muted").Update("muted", muted).Error
}

// SetMemberRole 仅站点站长可任命/撤销群管理员（admin <-> member）；不可改群主
func (s *ChatService) SetMemberRole(operatorSiteRole model.Role, roomID, targetID uint, role string) error {
	if operatorSiteRole != model.RoleOwner {
		return ErrChatSiteOwnerOnly
	}
	if role != model.ChatRoleAdmin && role != model.ChatRoleMember {
		return ErrChatInvalidRole
	}
	room, err := s.getRoom(roomID)
	if err != nil {
		return err
	}
	if room.RoomType != model.ChatRoomTypeGroup {
		return ErrChatOwnerOnly
	}
	target, err := s.membership(s.db, roomID, targetID)
	if err != nil {
		return err
	}
	if target.Role == model.ChatRoleOwner || room.OwnerID == targetID {
		return ErrChatOwnerOnly
	}
	return s.db.Model(&model.ChatRoomMember{}).
		Where("room_id = ? AND user_id = ?", roomID, targetID).
		Update("role", role).Error
}

// CountAdminRooms 用户作为群管理员的群数量
func (s *ChatService) CountAdminRooms(userID uint) (int64, error) {
	var n int64
	err := s.db.Model(&model.ChatRoomMember{}).
		Joins("JOIN chat_rooms ON chat_rooms.id = chat_room_members.room_id").
		Where("chat_room_members.user_id = ? AND chat_room_members.role = ? AND chat_rooms.deleted_at IS NULL AND chat_rooms.room_type = ?",
			userID, model.ChatRoleAdmin, model.ChatRoomTypeGroup).
		Count(&n).Error
	return n, err
}

// ListAdminRoomIDs 用户作为群管理员的群 ID 列表
func (s *ChatService) ListAdminRoomIDs(userID uint) ([]uint, error) {
	var ids []uint
	err := s.db.Model(&model.ChatRoomMember{}).
		Joins("JOIN chat_rooms ON chat_rooms.id = chat_room_members.room_id").
		Where("chat_room_members.user_id = ? AND chat_room_members.role = ? AND chat_rooms.deleted_at IS NULL AND chat_rooms.room_type = ?",
			userID, model.ChatRoleAdmin, model.ChatRoomTypeGroup).
		Pluck("chat_room_members.room_id", &ids).Error
	return ids, err
}

// CanAccessAdminMessages 可否进入后台消息管理
func (s *ChatService) CanAccessAdminMessages(actor *Actor) bool {
	if actor == nil {
		return false
	}
	if actor.HasSiteMessagePerm() {
		return true
	}
	n, err := s.CountAdminRooms(actor.ID)
	return err == nil && n > 0
}

// isChatRoomModerator 群主或群管理员
func (s *ChatService) isChatRoomModerator(userID, roomID uint) bool {
	m, err := s.membership(s.db, roomID, userID)
	if err != nil {
		return false
	}
	return m.Role == model.ChatRoleOwner || m.Role == model.ChatRoleAdmin
}

// hasSiteGroupMessagePerm 站点消息管理 flag（不含超管/站长，调用方通常已判 oversee）
func (s *ChatService) hasSiteGroupMessagePerm(userID uint) bool {
	var u model.User
	if err := s.db.Select("can_manage_messages").First(&u, userID).Error; err != nil {
		return false
	}
	return u.CanManageMessages
}

// canModerateRoomMessages 可撤回他人消息 / 看已撤回正文：全站监管、站点消息管（仅群）、群主/群管
func (s *ChatService) canModerateRoomMessages(userID, roomID uint, oversee bool) bool {
	if oversee {
		return true
	}
	if s.isChatRoomModerator(userID, roomID) {
		return true
	}
	if !s.hasSiteGroupMessagePerm(userID) {
		return false
	}
	room, err := s.getRoom(roomID)
	if err != nil {
		return false
	}
	return room.RoomType == model.ChatRoomTypeGroup
}

// SendMessage 发送群消息：成员且未被禁言；可选引用回复；解析@并落提醒通知。
func (s *ChatService) SendMessage(senderID, roomID uint, content string, replyToID uint) (*model.ChatMessage, []uint, error) {
	content = strings.TrimSpace(content)
	if content == "" {
		return nil, nil, ErrChatContentEmpty
	}
	if len([]rune(content)) > chatMsgMaxRune {
		return nil, nil, ErrChatContentTooLong
	}
	if _, err := s.getRoom(roomID); err != nil {
		return nil, nil, err
	}
	m, err := s.membership(s.db, roomID, senderID)
	if err != nil {
		return nil, nil, err
	}
	if m.Muted {
		return nil, nil, ErrChatMuted
	}

	replySnap := ""
	if replyToID > 0 {
		var quoted model.ChatMessage
		if err := s.db.Where("id = ? AND room_id = ?", replyToID, roomID).
			Preload("Sender").First(&quoted).Error; err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return nil, nil, ErrChatMsgNotFound
			}
			return nil, nil, err
		}
		name := quoted.Sender.Nickname
		if name == "" {
			name = quoted.Sender.Username
		}
		if quoted.RecalledAt != nil {
			replySnap = name + ": （已撤回的消息）"
		} else {
			snippet := quoted.Content
			rs := []rune(snippet)
			if len(rs) > 80 {
				snippet = string(rs[:80]) + "…"
			}
			replySnap = name + ": " + snippet
		}
	}

	mentionIDs := s.resolveMentions(roomID, senderID, content)

	msg := &model.ChatMessage{
		RoomID:     roomID,
		SenderID:   senderID,
		Content:    content,
		ReplyToID:  replyToID,
		ReplySnap:  replySnap,
		MentionIDs: joinMentionIDs(mentionIDs),
	}
	err = s.db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(msg).Error; err != nil {
			return err
		}
		if err := tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
			Updates(map[string]interface{}{
				"last_message_id": msg.ID,
				"updated_at":      time.Now(),
			}).Error; err != nil {
			return err
		}
		// 发送者同步推进已读水位，避免切房时把刚发出的消息算成未读
		return tx.Model(&model.ChatRoomMember{}).
			Where("room_id = ? AND user_id = ? AND last_read_message_id < ?", roomID, senderID, msg.ID).
			Update("last_read_message_id", msg.ID).Error
	})
	if err != nil {
		return nil, nil, err
	}
	if err := s.db.Preload("Sender").First(msg, msg.ID).Error; err != nil {
		return nil, nil, err
	}
	for _, uid := range mentionIDs {
		s.notif.CreateMention(uid, senderID, roomID, msg.ID, content)
	}
	return msg, mentionIDs, nil
}

// resolveMentions 文本中 @用户名 → 群成员用户 ID（去重、排除自己、上限 20）
func (s *ChatService) resolveMentions(roomID, senderID uint, content string) []uint {
	matches := chatMentionRe.FindAllStringSubmatch(content, -1)
	if len(matches) == 0 {
		return nil
	}
	nameSet := make(map[string]struct{}, len(matches))
	names := make([]string, 0, len(matches))
	for _, mt := range matches {
		name := strings.ToLower(mt[1])
		if _, ok := nameSet[name]; ok {
			continue
		}
		nameSet[name] = struct{}{}
		names = append(names, name)
	}
	if len(names) == 0 {
		return nil
	}
	// 用户名大小写不敏感匹配（注册名唯一但比较时统一 lower）
	var users []model.User
	s.db.Where("LOWER(username) IN ? AND banned = ?", names, false).Find(&users)
	if len(users) == 0 {
		return nil
	}
	userIDs := make([]uint, 0, len(users))
	for _, u := range users {
		userIDs = append(userIDs, u.ID)
	}
	var memberIDs []uint
	s.db.Model(&model.ChatRoomMember{}).
		Where("room_id = ? AND user_id IN ?", roomID, userIDs).
		Pluck("user_id", &memberIDs)
	seen := make(map[uint]struct{}, len(memberIDs))
	out := make([]uint, 0, len(memberIDs))
	for _, id := range memberIDs {
		if id == senderID {
			continue
		}
		if _, ok := seen[id]; ok {
			continue
		}
		seen[id] = struct{}{}
		out = append(out, id)
		if len(out) >= chatMentionMax {
			break
		}
	}
	return out
}

func joinMentionIDs(ids []uint) string {
	if len(ids) == 0 {
		return ""
	}
	parts := make([]string, len(ids))
	for i, id := range ids {
		parts[i] = strconv.FormatUint(uint64(id), 10)
	}
	return strings.Join(parts, ",")
}

// ListMessages 历史消息分页：成员或监管者可取；已撤回消息仍返回（前端显示占位）
func (s *ChatService) ListMessages(userID, roomID, beforeID uint, size int, oversee bool) ([]model.ChatMessage, bool, error) {
	if size < 1 || size > 50 {
		size = 30
	}
	if _, err := s.getRoom(roomID); err != nil {
		return nil, false, err
	}
	if !oversee {
		if _, err := s.membership(s.db, roomID, userID); err != nil {
			return nil, false, err
		}
	}
	q := s.db.Where("room_id = ?", roomID)
	if beforeID > 0 {
		q = q.Where("id < ?", beforeID)
	}
	var msgs []model.ChatMessage
	if err := q.Order("id DESC").Limit(size + 1).Preload("Sender").Preload("Recaller").Find(&msgs).Error; err != nil {
		return nil, false, err
	}
	hasMore := len(msgs) > size
	if hasMore {
		msgs = msgs[:size]
	}
	for i, j := 0, len(msgs)-1; i < j; i, j = i+1, j-1 {
		msgs[i], msgs[j] = msgs[j], msgs[i]
	}
	// 已撤回正文：监管者 / 站点消息管（群）/ 群主群管保留
	seeRecalled := oversee || s.canModerateRoomMessages(userID, roomID, false)
	if !seeRecalled {
		for i := range msgs {
			if msgs[i].RecalledAt != nil {
				msgs[i].Content = ""
			}
		}
	}
	return msgs, hasMore, nil
}

// RecallMessage 撤回消息：本人；或群主/群管/站点消息管（群）/全站监管可撤他人。
// newly=true 表示本次刚打上撤回标记（已撤回的幂等调用为 false，避免重复回退角标）。
func (s *ChatService) RecallMessage(operatorID, roomID, messageID uint, oversee bool) (*model.ChatMessage, bool, error) {
	if _, err := s.getRoom(roomID); err != nil {
		return nil, false, err
	}
	var msg model.ChatMessage
	if err := s.db.Where("id = ? AND room_id = ?", messageID, roomID).First(&msg).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, false, ErrChatMsgNotFound
		}
		return nil, false, err
	}
	if msg.RecalledAt != nil {
		return &msg, false, nil // 幂等
	}
	if msg.SenderID == operatorID {
		if !oversee {
			if _, err := s.membership(s.db, roomID, operatorID); err != nil {
				return nil, false, err
			}
		}
	} else if !s.canModerateRoomMessages(operatorID, roomID, oversee) {
		return nil, false, ErrChatRecallDenied
	}
	now := time.Now()
	if err := s.db.Model(&msg).Updates(map[string]interface{}{
		"recalled_at": now,
		"recalled_by": operatorID,
	}).Error; err != nil {
		return nil, false, err
	}
	msg.RecalledAt = &now
	msg.RecalledBy = operatorID
	_ = s.db.Preload("Sender").Preload("Recaller").First(&msg, msg.ID)
	return &msg, true, nil
}

// AdminChatParticipant 管理端私聊双方摘要
type AdminChatParticipant struct {
	ID     uint   `json:"id"`
	Name   string `json:"name"`
	Avatar string `json:"avatar"`
}

// AdminChatMessageItem 管理端消息监管列表项（群聊 / 大厅 / 私聊）
type AdminChatMessageItem struct {
	ID           uint                   `json:"id"`
	RoomID       uint                   `json:"room_id"`
	RoomName     string                 `json:"room_name"`
	RoomType     string                 `json:"room_type"` // group | direct
	IsDefault    bool                   `json:"is_default"`
	SenderID     uint                   `json:"sender_id"`
	SenderName   string                 `json:"sender_name"`
	SenderAvatar string                 `json:"sender_avatar"`
	Participants []AdminChatParticipant `json:"participants,omitempty"` // 私聊双方
	Content      string                 `json:"content"`
	RecalledAt   *time.Time             `json:"recalled_at,omitempty"`
	CreatedAt    time.Time              `json:"created_at"`
}

// AdminListMessages 按房间类型分页；scope 限制可见房间；非全站监管脱敏已撤回正文。
// actor 为站长/超管：全站；HasSiteMessagePerm：全部群聊（无私聊）；否则仅群管房间。
func (s *ChatService) AdminListMessages(actor *Actor, page int, keyword, roomType string) ([]AdminChatMessageItem, int64, error) {
	if actor == nil || !s.CanAccessAdminMessages(actor) {
		return nil, 0, ErrChatAdminAccess
	}
	if page < 1 {
		page = 1
	}
	fullOversee := CanOverseeChat(actor.Role)
	siteGroup := actor.HasSiteMessagePerm() && !fullOversee
	if roomType != model.ChatRoomTypeGroup && roomType != model.ChatRoomTypeDirect {
		return nil, 0, errors.New("房间类型无效")
	}
	// 非全站监管不可看私聊
	if roomType == model.ChatRoomTypeDirect && !fullOversee {
		return []AdminChatMessageItem{}, 0, nil
	}
	const pageSize = 15
	q := s.db.Model(&model.ChatMessage{}).
		Joins("JOIN chat_rooms ON chat_rooms.id = chat_messages.room_id").
		Joins("LEFT JOIN users ON users.id = chat_messages.sender_id").
		Where("chat_rooms.deleted_at IS NULL AND chat_messages.deleted_at IS NULL").
		Where("chat_rooms.room_type = ?", roomType)

	if !fullOversee && !siteGroup {
		ids, err := s.ListAdminRoomIDs(actor.ID)
		if err != nil {
			return nil, 0, err
		}
		if len(ids) == 0 {
			return []AdminChatMessageItem{}, 0, nil
		}
		q = q.Where("chat_messages.room_id IN ?", ids)
	} else if siteGroup {
		q = q.Where("chat_rooms.room_type = ?", model.ChatRoomTypeGroup)
	}

	if kw := strings.TrimSpace(keyword); kw != "" {
		like := "%" + kw + "%"
		q = q.Where(
			`chat_messages.content ILIKE ? OR chat_rooms.name ILIKE ? OR users.nickname ILIKE ? OR users.username ILIKE ?
			 OR EXISTS (
			   SELECT 1 FROM chat_room_members crm
			   JOIN users mu ON mu.id = crm.user_id
			   WHERE crm.room_id = chat_messages.room_id
			     AND (mu.nickname ILIKE ? OR mu.username ILIKE ?)
			 )`,
			like, like, like, like, like, like,
		)
	}
	var total int64
	if err := q.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	var msgs []model.ChatMessage
	if err := q.Preload("Sender").
		Order("chat_messages.id DESC").
		Offset((page - 1) * pageSize).
		Limit(pageSize).
		Find(&msgs).Error; err != nil {
		return nil, 0, err
	}
	roomIDs := make([]uint, 0, len(msgs))
	seen := map[uint]struct{}{}
	for _, m := range msgs {
		if _, ok := seen[m.RoomID]; !ok {
			seen[m.RoomID] = struct{}{}
			roomIDs = append(roomIDs, m.RoomID)
		}
	}
	roomMap := map[uint]model.ChatRoom{}
	if len(roomIDs) > 0 {
		var rooms []model.ChatRoom
		s.db.Where("id IN ?", roomIDs).Find(&rooms)
		for _, r := range rooms {
			roomMap[r.ID] = r
		}
	}
	participantsByRoom := map[uint][]AdminChatParticipant{}
	if roomType == model.ChatRoomTypeDirect && len(roomIDs) > 0 {
		var members []model.ChatRoomMember
		s.db.Where("room_id IN ?", roomIDs).Preload("User").Preload("User.Badges.Badge").Find(&members)
		for i := range members {
			name := members[i].User.Nickname
			if name == "" {
				name = members[i].User.Username
			}
			if name == "" {
				name = "?"
			}
			participantsByRoom[members[i].RoomID] = append(participantsByRoom[members[i].RoomID], AdminChatParticipant{
				ID: members[i].UserID, Name: name, Avatar: members[i].User.Avatar,
			})
		}
	}
	out := make([]AdminChatMessageItem, 0, len(msgs))
	for _, m := range msgs {
		r := roomMap[m.RoomID]
		name := r.Name
		parts := participantsByRoom[r.ID]
		if r.IsDefault {
			name = "全站大厅"
		} else if r.RoomType == model.ChatRoomTypeDirect {
			names := make([]string, 0, len(parts))
			for _, p := range parts {
				names = append(names, p.Name)
			}
			if len(names) > 0 {
				name = strings.Join(names, " · ")
			} else if name == "" {
				name = "私聊"
			}
		}
		content := m.Content
		// 后台列表：仅全站监管可见已撤回正文；群管/消息管理员在前台会话内可看
		if !fullOversee && m.RecalledAt != nil {
			content = ""
		}
		item := AdminChatMessageItem{
			ID: m.ID, RoomID: m.RoomID, RoomName: name, RoomType: r.RoomType, IsDefault: r.IsDefault,
			SenderID: m.SenderID, Content: content, RecalledAt: m.RecalledAt, CreatedAt: m.CreatedAt,
			Participants: parts,
		}
		if m.Sender.ID > 0 {
			item.SenderName = m.Sender.Nickname
			if item.SenderName == "" {
				item.SenderName = m.Sender.Username
			}
			item.SenderAvatar = m.Sender.Avatar
		}
		out = append(out, item)
	}
	return out, total, nil
}

// MarkRead 把已读水位推进到指定消息（单调不减；messageID=0 或超过最新则取最新）
func (s *ChatService) MarkRead(userID, roomID, messageID uint) error {
	room, err := s.getRoom(roomID)
	if err != nil {
		return err
	}
	if _, err := s.membership(s.db, roomID, userID); err != nil {
		return err
	}
	if messageID == 0 || messageID > room.LastMessageID {
		messageID = room.LastMessageID
	}
	return s.db.Model(&model.ChatRoomMember{}).
		Where("room_id = ? AND user_id = ? AND last_read_message_id < ?", roomID, userID, messageID).
		Update("last_read_message_id", messageID).Error
}

// UnreadSummary 当前用户所有群的未读明细与总数
func (s *ChatService) UnreadSummary(userID uint) (int64, []UnreadRoom, error) {
	var rows []UnreadRoom
	err := s.db.Table("chat_messages AS m").
		Select("m.room_id AS room_id, count(*) AS cnt").
		Joins("JOIN chat_room_members AS rm ON rm.room_id = m.room_id AND rm.user_id = ?", userID).
		Where("m.id > rm.last_read_message_id AND m.sender_id <> ? AND m.deleted_at IS NULL AND m.recalled_at IS NULL", userID).
		Group("m.room_id").
		Scan(&rows).Error
	if err != nil {
		return 0, nil, err
	}
	var total int64
	for _, r := range rows {
		total += r.Count
	}
	return total, rows, nil
}

// TotalUnread 供 /me SSR 一次调用（Header 红点直出）
func (s *ChatService) TotalUnread(userID uint) int64 {
	total, _, _ := s.UnreadSummary(userID)
	return total
}