backend/pkg/chat/usecase/room.go

package usecase

import (
	"backend/pkg/chat/domain/chat"
	"backend/pkg/chat/domain/entity"
	"backend/pkg/chat/domain/repository"
	"backend/pkg/chat/domain/usecase"
	"backend/pkg/library/cassandra"
	errs "backend/pkg/library/errors"
	"context"
	"fmt"
	"time"

	"github.com/gocql/gocql"
)

const (
	defaultRoomPageSize = 20
	maxRoomPageSize     = 100
	defaultRoomStatus   = "active"
	defaultMemberRole   = "member"
)

type RoomUseCaseParam struct {
	RoomRepo repository.RoomRepository
	Logger   errs.Logger
}

type RoomUseCase struct {
	RoomUseCaseParam
}

// NewRoomUseCase 創建新的聊天室 UseCase
func NewRoomUseCase(param RoomUseCaseParam) usecase.RoomUseCase {
	return &RoomUseCase{
		param,
	}
}

// ==================== 聊天室管理 ====================

func (uc *RoomUseCase) CreateRoom(ctx context.Context, req usecase.CreateRoomReq) (*usecase.Room, error) {
	// 驗證輸入參數
	if err := uc.validateCreateRoomReq(req); err != nil {
		return nil, err
	}

	// 設置預設值
	status := req.Status
	if status == "" {
		status = defaultRoomStatus
	}

	// 創建聊天室實體
	now := time.Now().UTC().UnixNano()
	room := &entity.Room{
		Name:      req.Name,
		Status:    status,
		CreatedAt: now,
		UpdatedAt: now,
	}

	// 保存聊天室
	if err := uc.RoomRepo.Create(ctx, room); err != nil {
		return nil, uc.logError("RoomRepo.Create", req, err, "failed to create room")
	}

	// 將創建者添加為管理員
	member := &entity.RoomMember{
		RoomID:   room.RoomID,
		UID:      req.UID,
		Role:     chat.RoomRoleAdmin.String(),
		JoinedAt: now,
	}
	if err := uc.RoomRepo.Insert(ctx, member); err != nil {
		// 如果添加成員失敗，嘗試刪除已創建的聊天室（清理）
		_ = uc.RoomRepo.RoomDelete(ctx, room.RoomID.String())
		return nil, uc.logError("RoomRepo.Insert", req, err, "failed to add creator as admin")
	}

	return uc.entityRoomToUseCase(room), nil
}

func (uc *RoomUseCase) GetRoom(ctx context.Context, req usecase.GetRoomReq) (*usecase.Room, error) {
	// 驗證輸入參數
	if err := uc.validateGetRoomReq(req); err != nil {
		return nil, err
	}

	// 檢查用戶是否在聊天室中
	isInRoom, err := uc.RoomRepo.IsUserInRoom(ctx, req.UID, req.RoomID)
	if err != nil {
		return nil, uc.logError("RoomRepo.IsUserInRoom", req, err, "failed to check user in room")
	}
	if !isInRoom {
		return nil, errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "uid", Val: req.UID},
				{Key: "room_id", Val: req.RoomID},
			},
			"user is not in the room")
	}

	// 取得聊天室資訊
	room, err := uc.RoomRepo.RoomGet(ctx, req.RoomID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return nil, errs.ResNotFoundErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "room_id", Val: req.RoomID},
				},
				"room not found")
		}
		return nil, uc.logError("RoomRepo.RoomGet", req, err, "failed to get room")
	}

	return uc.entityRoomToUseCase(room), nil
}

func (uc *RoomUseCase) UpdateRoom(ctx context.Context, req usecase.UpdateRoomReq) (*usecase.Room, error) {
	// 驗證輸入參數
	if err := uc.validateUpdateRoomReq(req); err != nil {
		return nil, err
	}

	// 檢查用戶是否在聊天室中且為管理員
	member, err := uc.RoomRepo.Get(ctx, req.RoomID, req.UID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return nil, errs.AuthForbiddenErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "uid", Val: req.UID},
					{Key: "room_id", Val: req.RoomID},
				},
				"user is not in the room")
		}
		return nil, uc.logError("RoomRepo.Get", req, err, "failed to get member")
	}

	// 檢查是否為管理員
	role := chat.RoomRole(member.Role)
	if !role.IsAdmin() {
		return nil, errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "uid", Val: req.UID},
				{Key: "room_id", Val: req.RoomID},
				{Key: "role", Val: member.Role},
			},
			"only admin can update room")
	}

	// 取得現有聊天室資訊
	room, err := uc.RoomRepo.RoomGet(ctx, req.RoomID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return nil, errs.ResNotFoundErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "room_id", Val: req.RoomID},
				},
				"room not found")
		}
		return nil, uc.logError("RoomRepo.RoomGet", req, err, "failed to get room")
	}

	// 更新欄位
	if req.Name != nil {
		room.Name = *req.Name
	}
	if req.Status != nil {
		room.Status = *req.Status
	}
	room.UpdatedAt = time.Now().UTC().UnixNano()

	// 保存更新
	if err := uc.RoomRepo.RoomUpdate(ctx, room); err != nil {
		return nil, uc.logError("RoomRepo.RoomUpdate", req, err, "failed to update room")
	}

	return uc.entityRoomToUseCase(room), nil
}

func (uc *RoomUseCase) DeleteRoom(ctx context.Context, req usecase.DeleteRoomReq) error {
	// 驗證輸入參數
	if err := uc.validateDeleteRoomReq(req); err != nil {
		return err
	}

	// 檢查用戶是否在聊天室中且為管理員
	member, err := uc.RoomRepo.Get(ctx, req.RoomID, req.UID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return errs.AuthForbiddenErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "uid", Val: req.UID},
					{Key: "room_id", Val: req.RoomID},
				},
				"user is not in the room")
		}
		return uc.logError("RoomRepo.Get", req, err, "failed to get member")
	}

	// 檢查是否為管理員
	role := chat.RoomRole(member.Role)
	if !role.IsAdmin() {
		return errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "uid", Val: req.UID},
				{Key: "room_id", Val: req.RoomID},
				{Key: "role", Val: member.Role},
			},
			"only admin can delete room")
	}

	// 刪除聊天室（會同時刪除相關的成員和訊息）
	if err := uc.RoomRepo.RoomDelete(ctx, req.RoomID); err != nil {
		if cassandra.IsNotFound(err) {
			return errs.ResNotFoundErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "room_id", Val: req.RoomID},
				},
				"room not found")
		}
		return uc.logError("RoomRepo.RoomDelete", req, err, "failed to delete room")
	}

	return nil
}

func (uc *RoomUseCase) ListRooms(ctx context.Context, req usecase.ListRoomsReq) ([]usecase.Room, string, int64, error) {
	// 驗證輸入參數
	if err := uc.validateListRoomsReq(req); err != nil {
		return nil, "", 0, err
	}

	// 設置預設值
	pageSize := req.PageSize
	if pageSize <= 0 {
		pageSize = defaultRoomPageSize
	}
	if pageSize > maxRoomPageSize {
		pageSize = maxRoomPageSize
	}

	// 查詢用戶所在的聊天室
	userRooms, err := uc.RoomRepo.GetUserRooms(ctx, req.UID)
	if err != nil {
		return nil, "", 0, uc.logError("RoomRepo.GetUserRooms", req, err, "failed to get user rooms")
	}

	// 如果沒有聊天室，直接返回
	if len(userRooms) == 0 {
		return []usecase.Room{}, "", 0, nil
	}

	// 取得聊天室 ID 列表
	roomIDs := make([]string, 0, len(userRooms))
	for _, ur := range userRooms {
		roomIDs = append(roomIDs, ur.RoomID.String())
	}

	// 根據 ID 列表查詢聊天室詳細資訊
	rooms, err := uc.RoomRepo.RoomGetByID(ctx, roomIDs)
	if err != nil {
		return nil, "", 0, uc.logError("RoomRepo.RoomGetByID", req, err, "failed to get rooms by id")
	}

	// 篩選狀態
	if req.Status != "" {
		filtered := make([]entity.Room, 0, len(rooms))
		for _, room := range rooms {
			if room.Status == req.Status {
				filtered = append(filtered, room)
			}
		}
		rooms = filtered
	}

	// 轉換為 usecase.Room
	result := make([]usecase.Room, 0, len(rooms))
	for _, room := range rooms {
		result = append(result, *uc.entityRoomToUseCase(&room))
	}

	// 計算總數（僅第一頁）
	var total int64
	if req.LastID == "" {
		total = int64(len(result))
	}

	// 返回最後一個 ID（用於分頁）
	lastID := ""
	if len(result) > 0 {
		lastID = result[len(result)-1].RoomID
	}

	return result, lastID, total, nil
}

func (uc *RoomUseCase) IsUserInRoom(ctx context.Context, req usecase.IsUserInRoomReq) (bool, error) {
	// 驗證輸入參數
	if err := uc.validateIsUserInRoomReq(req); err != nil {
		return false, err
	}

	// 檢查用戶是否在聊天室中
	isInRoom, err := uc.RoomRepo.IsUserInRoom(ctx, req.UID, req.RoomID)
	if err != nil {
		return false, uc.logError("RoomRepo.IsUserInRoom", req, err, "failed to check user in room")
	}

	return isInRoom, nil
}

// ==================== 成員管理 ====================

func (uc *RoomUseCase) AddMember(ctx context.Context, req usecase.AddMemberReq) (*usecase.Member, error) {
	// 驗證輸入參數
	if err := uc.validateAddMemberReq(req); err != nil {
		return nil, err
	}

	// 檢查操作者是否在聊天室中且為管理員
	operator, err := uc.RoomRepo.Get(ctx, req.RoomID, req.UID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return nil, errs.AuthForbiddenErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "uid", Val: req.UID},
					{Key: "room_id", Val: req.RoomID},
				},
				"operator is not in the room")
		}
		return nil, uc.logError("RoomRepo.Get", req, err, "failed to get operator")
	}

	// 檢查是否為管理員
	operatorRole := chat.RoomRole(operator.Role)
	if !operatorRole.IsAdmin() {
		return nil, errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "uid", Val: req.UID},
				{Key: "room_id", Val: req.RoomID},
				{Key: "role", Val: operator.Role},
			},
			"only admin can add members")
	}

	// 檢查要添加的用戶是否已在聊天室中
	existing, err := uc.RoomRepo.Get(ctx, req.RoomID, req.MemberUID)
	if err == nil && existing != nil {
		return nil, errs.InputInvalidFormatError("user is already in the room")
	}

	// 設置預設角色
	role := req.Role
	if role == "" {
		role = defaultMemberRole
	}

	// 驗證角色
	roleEnum := chat.RoomRole(role)
	if !roleEnum.IsValid() || roleEnum.IsOwner() {
		return nil, errs.InputInvalidFormatError("invalid role")
	}

	// 創建成員實體
	now := time.Now().UTC().UnixNano()
	roomUUID, err := gocql.ParseUUID(req.RoomID)
	if err != nil {
		return nil, errs.InputInvalidFormatError("invalid room_id format")
	}

	member := &entity.RoomMember{
		RoomID:   roomUUID,
		UID:      req.MemberUID,
		Role:     role,
		JoinedAt: now,
	}

	// 添加到聊天室
	if err := uc.RoomRepo.Insert(ctx, member); err != nil {
		return nil, uc.logError("RoomRepo.Insert", req, err, "failed to add member")
	}

	return uc.entityMemberToUseCase(member), nil
}

func (uc *RoomUseCase) RemoveMember(ctx context.Context, req usecase.RemoveMemberReq) error {
	// 驗證輸入參數
	if err := uc.validateRemoveMemberReq(req); err != nil {
		return err
	}

	// 檢查操作者是否在聊天室中
	operator, err := uc.RoomRepo.Get(ctx, req.RoomID, req.UID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return errs.AuthForbiddenErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "uid", Val: req.UID},
					{Key: "room_id", Val: req.RoomID},
				},
				"operator is not in the room")
		}
		return uc.logError("RoomRepo.Get", req, err, "failed to get operator")
	}

	// 檢查要移除的成員
	member, err := uc.RoomRepo.Get(ctx, req.RoomID, req.MemberUID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return errs.ResNotFoundErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "member_uid", Val: req.MemberUID},
					{Key: "room_id", Val: req.RoomID},
				},
				"member not found")
		}
		return uc.logError("RoomRepo.Get", req, err, "failed to get member")
	}

	// 檢查權限：管理員可以移除任何人，普通成員只能移除自己
	operatorRole := chat.RoomRole(operator.Role)
	if !operatorRole.IsAdmin() {
		if req.UID != req.MemberUID {
			return errs.AuthForbiddenErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "uid", Val: req.UID},
					{Key: "member_uid", Val: req.MemberUID},
					{Key: "room_id", Val: req.RoomID},
				},
				"only admin can remove other members")
		}
	}

	// 不能移除擁有者
	memberRole := chat.RoomRole(member.Role)
	if memberRole.IsOwner() {
		return errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "member_uid", Val: req.MemberUID},
				{Key: "room_id", Val: req.RoomID},
			},
			"cannot remove owner")
	}

	// 移除成員
	if err := uc.RoomRepo.DeleteMember(ctx, req.RoomID, req.MemberUID); err != nil {
		return uc.logError("RoomRepo.DeleteMember", req, err, "failed to remove member")
	}

	return nil
}

func (uc *RoomUseCase) UpdateMemberRole(ctx context.Context, req usecase.UpdateMemberRoleReq) (*usecase.Member, error) {
	// 驗證輸入參數
	if err := uc.validateUpdateMemberRoleReq(req); err != nil {
		return nil, err
	}

	// 檢查操作者是否在聊天室中且為管理員
	operator, err := uc.RoomRepo.Get(ctx, req.RoomID, req.UID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return nil, errs.AuthForbiddenErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "uid", Val: req.UID},
					{Key: "room_id", Val: req.RoomID},
				},
				"operator is not in the room")
		}
		return nil, uc.logError("RoomRepo.Get", req, err, "failed to get operator")
	}

	// 檢查是否為管理員
	operatorRole := chat.RoomRole(operator.Role)
	if !operatorRole.IsAdmin() {
		return nil, errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "uid", Val: req.UID},
				{Key: "room_id", Val: req.RoomID},
				{Key: "role", Val: operator.Role},
			},
			"only admin can update member role")
	}

	// 檢查要更新的成員
	member, err := uc.RoomRepo.Get(ctx, req.RoomID, req.MemberUID)
	if err != nil {
		if cassandra.IsNotFound(err) {
			return nil, errs.ResNotFoundErrorL(
				uc.Logger,
				[]errs.LogField{
					{Key: "member_uid", Val: req.MemberUID},
					{Key: "room_id", Val: req.RoomID},
				},
				"member not found")
		}
		return nil, uc.logError("RoomRepo.Get", req, err, "failed to get member")
	}

	// 驗證角色
	roleEnum := chat.RoomRole(req.Role)
	if !roleEnum.IsValid() || roleEnum.IsOwner() {
		return nil, errs.InputInvalidFormatError("invalid role")
	}

	// 不能修改擁有者的角色
	memberRole := chat.RoomRole(member.Role)
	if memberRole.IsOwner() {
		return nil, errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "member_uid", Val: req.MemberUID},
				{Key: "room_id", Val: req.RoomID},
			},
			"cannot update owner role")
	}

	// 更新角色
	member.Role = req.Role
	if err := uc.RoomRepo.UpdateRole(ctx, member); err != nil {
		return nil, uc.logError("RoomRepo.UpdateRole", req, err, "failed to update member role")
	}

	return uc.entityMemberToUseCase(member), nil
}

func (uc *RoomUseCase) ListMembers(ctx context.Context, req usecase.ListMembersReq) ([]usecase.Member, int64, error) {
	// 驗證輸入參數
	if err := uc.validateListMembersReq(req); err != nil {
		return nil, 0, err
	}

	// 檢查用戶是否在聊天室中
	isInRoom, err := uc.RoomRepo.IsUserInRoom(ctx, req.UID, req.RoomID)
	if err != nil {
		return nil, 0, uc.logError("RoomRepo.IsUserInRoom", req, err, "failed to check user in room")
	}
	if !isInRoom {
		return nil, 0, errs.AuthForbiddenErrorL(
			uc.Logger,
			[]errs.LogField{
				{Key: "uid", Val: req.UID},
				{Key: "room_id", Val: req.RoomID},
			},
			"user is not in the room")
	}

	// 查詢所有成員
	members, err := uc.RoomRepo.AllMembers(ctx, req.RoomID)
	if err != nil {
		return nil, 0, uc.logError("RoomRepo.AllMembers", req, err, "failed to list members")
	}

	// 轉換為 usecase.Member
	result := make([]usecase.Member, 0, len(members))
	for _, member := range members {
		result = append(result, *uc.entityMemberToUseCase(&member))
	}

	// 計算總數
	total, err := uc.RoomRepo.Count(ctx, req.RoomID)
	if err != nil {
		return nil, 0, uc.logError("RoomRepo.Count", req, err, "failed to count members")
	}

	return result, total, nil
}

// ==================== 用戶相關 ====================

func (uc *RoomUseCase) GetUserRooms(ctx context.Context, req usecase.GetUserRoomsReq) ([]usecase.Room, int64, error) {
	// 驗證輸入參數
	if err := uc.validateGetUserRoomsReq(req); err != nil {
		return nil, 0, err
	}

	// 查詢用戶所在的聊天室
	userRooms, err := uc.RoomRepo.GetUserRooms(ctx, req.UID)
	if err != nil {
		return nil, 0, uc.logError("RoomRepo.GetUserRooms", req, err, "failed to get user rooms")
	}

	// 如果沒有聊天室，直接返回
	if len(userRooms) == 0 {
		return []usecase.Room{}, 0, nil
	}

	// 取得聊天室 ID 列表
	roomIDs := make([]string, 0, len(userRooms))
	for _, ur := range userRooms {
		roomIDs = append(roomIDs, ur.RoomID.String())
	}

	// 根據 ID 列表查詢聊天室詳細資訊
	rooms, err := uc.RoomRepo.RoomGetByID(ctx, roomIDs)
	if err != nil {
		return nil, 0, uc.logError("RoomRepo.RoomGetByID", req, err, "failed to get rooms by id")
	}

	// 轉換為 usecase.Room
	result := make([]usecase.Room, 0, len(rooms))
	for _, room := range rooms {
		result = append(result, *uc.entityRoomToUseCase(&room))
	}

	// 計算總數
	total := int64(len(result))

	return result, total, nil
}

// ==================== 輔助方法 ====================

func (uc *RoomUseCase) entityRoomToUseCase(room *entity.Room) *usecase.Room {
	return &usecase.Room{
		RoomID:    room.RoomID.String(),
		Name:      room.Name,
		Status:    room.Status,
		CreatedAt: room.CreatedAt,
		UpdatedAt: room.UpdatedAt,
	}
}

func (uc *RoomUseCase) entityMemberToUseCase(member *entity.RoomMember) *usecase.Member {
	return &usecase.Member{
		RoomID:   member.RoomID.String(),
		UID:      member.UID,
		Role:     member.Role,
		JoinedAt: member.JoinedAt,
	}
}

// ==================== 驗證方法 ====================

func (uc *RoomUseCase) validateCreateRoomReq(req usecase.CreateRoomReq) error {
	if req.Name == "" {
		return errs.InputInvalidFormatError("name cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	if req.Status != "" && req.Status != "active" && req.Status != "archived" {
		return errs.InputInvalidFormatError("invalid status")
	}
	return nil
}

func (uc *RoomUseCase) validateGetRoomReq(req usecase.GetRoomReq) error {
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateUpdateRoomReq(req usecase.UpdateRoomReq) error {
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	if req.Name != nil && *req.Name == "" {
		return errs.InputInvalidFormatError("name cannot be empty")
	}
	if req.Status != nil && *req.Status != "active" && *req.Status != "archived" {
		return errs.InputInvalidFormatError("invalid status")
	}
	return nil
}

func (uc *RoomUseCase) validateDeleteRoomReq(req usecase.DeleteRoomReq) error {
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateListRoomsReq(req usecase.ListRoomsReq) error {
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateIsUserInRoomReq(req usecase.IsUserInRoomReq) error {
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateAddMemberReq(req usecase.AddMemberReq) error {
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	if req.MemberUID == "" {
		return errs.InputInvalidFormatError("member_uid cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateRemoveMemberReq(req usecase.RemoveMemberReq) error {
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	if req.MemberUID == "" {
		return errs.InputInvalidFormatError("member_uid cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateUpdateMemberRoleReq(req usecase.UpdateMemberRoleReq) error {
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	if req.MemberUID == "" {
		return errs.InputInvalidFormatError("member_uid cannot be empty")
	}
	if req.Role == "" {
		return errs.InputInvalidFormatError("role cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateListMembersReq(req usecase.ListMembersReq) error {
	if req.RoomID == "" {
		return errs.InputInvalidFormatError("room_id cannot be empty")
	}
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	return nil
}

func (uc *RoomUseCase) validateGetUserRoomsReq(req usecase.GetUserRoomsReq) error {
	if req.UID == "" {
		return errs.InputInvalidFormatError("uid cannot be empty")
	}
	return nil
}

// ==================== 錯誤日誌 ====================

func (uc *RoomUseCase) logError(funcName string, req interface{}, err error, message string) error {
	return errs.DBErrorErrorL(
		uc.Logger,
		[]errs.LogField{
			{Key: "func", Val: funcName},
			{Key: "req", Val: fmt.Sprintf("%+v", req)},
			{Key: "err", Val: err.Error()},
		},
		message,
	).Wrap(err)
}