回收站模块实现教程

// Trash 将文件/文件夹移入回收站（软删除）。
// 文件：状态改为 trashed(1) + 写入 recycle_bins，可恢复，不扣减配额。
// 文件夹：写 recycle_bins（记父目录 ID）→ 软删除内部文件 → 物理删除 folder 记录。
// 不扣减用户已用存储空间（文件仍在占用空间）。
func (uc *RecycleUsecase) Trash(ctx context.Context, userID uint64, fileIDs, folderIDs []uint64) ([]uint64, []uint64, error) {
	// 修正点（商用）：先全量校验文件所有权，任一越权直接整体失败，避免"半移入回收站"中间态
	if len(fileIDs) > 0 {
		files, err := uc.fileRepo.FindByIDs(ctx, fileIDs)
		if err != nil {
			return nil, nil, err
		}
		owned := make(map[uint64]*File, len(files))
		for _, f := range files {
			if f.UserID != userID {
				return nil, nil, ErrForbidden // 越权：禁止把他人文件移入自己回收站
			}
			owned[f.ID] = f
		}
		now := time.Now()
		expire := now.Add(7 * 24 * time.Hour) // 保留 7 天
		for _, f := range files {
			item := &RecycleItem{
				UserID:    userID,
				ItemType:  "file",
				ItemID:    f.ID,
				Name:      f.Name,
				FileSize:  f.Size,
				FileType:  f.Type,
				DeletedAt: now,
				ExpireAt:  expire,
			}
			if _, err := uc.recycleRepo.Create(ctx, item); err != nil {
				return nil, nil, err
			}
			if uc.shareRepo != nil {
				_ = uc.shareRepo.DeleteByItemID(ctx, "file", f.ID) // 源文件删除，分享也应删除
			}
		}
		ids := make([]uint64, 0, len(files))
		for _, f := range files {
			ids = append(ids, f.ID)
		}
		if err := uc.fileRepo.BatchUpdateStatus(ctx, ids, 1); err != nil {
			return nil, nil, err
		}
	}

	// 文件夹分支：逐文件夹校验所有权 → 写回收站 → 软删除内部文件 → 物理删除 folder 记录
	for _, fid := range folderIDs {
		folder, err := uc.folderRepo.FindByID(ctx, fid)
		if err != nil {
			return nil, nil, err
		}
		if folder.UserID != userID {
			return nil, nil, ErrForbidden
		}
		originalPath := "0"
		if folder.ParentID != nil {
			originalPath = fmt.Sprintf("%d", *folder.ParentID)
		}
		now := time.Now()
		item := &RecycleItem{
			UserID: userID, ItemType: "folder", ItemID: fid,
			OriginalPath: originalPath, Name: folder.Name, FileSize: 0,
			FileType: "folder", DeletedAt: now, ExpireAt: now.Add(7 * 24 * time.Hour),
		}
		if _, err := uc.recycleRepo.Create(ctx, item); err != nil {
			return nil, nil, err
		}
		// 软删除该文件夹下所有活跃文件（status=0 → 1）
		activeFiles, _, _ := uc.fileRepo.ListByParent(ctx, userID, &fid, 0, "", 100000, "", "")
		if len(activeFiles) > 0 {
			ids := make([]uint64, len(activeFiles))
			for i, f := range activeFiles {
				ids[i] = f.ID
			}
			_ = uc.fileRepo.BatchUpdateStatus(ctx, ids, 1)
		}
		// 递归软删除子目录下文件 + 物理删除子文件夹记录
		subDirIDs, _ := uc.folderRepo.ListAllSubDirectoryIDs(ctx, userID, fid)
		for _, subID := range subDirIDs {
			subFiles, _, _ := uc.fileRepo.ListByParent(ctx, userID, &subID, 0, "", 100000, "", "")
			if len(subFiles) > 0 {
				ids := make([]uint64, len(subFiles))
				for i, f := range subFiles {
					ids[i] = f.ID
				}
				_ = uc.fileRepo.BatchUpdateStatus(ctx, ids, 1)
			}
			_ = uc.folderRepo.Delete(ctx, subID)
		}
		if err := uc.folderRepo.Delete(ctx, fid); err != nil {
			return nil, nil, err
		}
		if uc.shareRepo != nil {
			_ = uc.shareRepo.DeleteByItemID(ctx, "folder", fid)
		}
	}

	// 清理文件列表缓存、文件元数据缓存、存储缓存，保证前端刷新一致
	if uc.cache != nil {
		_ = uc.cache.DeleteByPattern(ctx, fmt.Sprintf("files:list:%d:*", userID))
		_ = uc.cache.Delete(ctx, fmt.Sprintf(cacheKeyUserStorage, userID))
	}
	if uc.eventPublisher != nil {
		_ = uc.eventPublisher.Publish(ctx, EventFileTrashed, &FileChangedPayload{
			UserID: userID, Action: "trashed",
		})
	}
	return fileIDs, folderIDs, nil
}

// biz 层
func (uc *RecycleUsecase) ListRecycle(ctx context.Context, userID uint64, cursor string, pageSize int) ([]*RecycleItem, string, bool, error) {
	if pageSize <= 0 {
		pageSize = 20
	}
	items, nextCursor, err := uc.recycleRepo.ListByUser(ctx, userID, cursor, pageSize)
	if err != nil {
		return nil, "", false, err
	}
	hasMore := len(items) >= pageSize
	return items, nextCursor, hasMore, nil
}

// data 层（keyset 分页核心，修正点：改用 (deleted_at, id) 复合游标避免同秒歧义）
func (r *recycleRepo) ListByUser(ctx context.Context, userID uint64, cursor string, limit int) ([]*biz.RecycleItem, string, error) {
	query := r.db.WithContext(ctx).Model(&model.RecycleBin{}).Where("user_id = ?", userID)
	// 修正点：cursor 形如 "2025-08-01 12:00:00|123"，拆成 deleted_at 与 id 两段
	if cursor != "" {
		parts := strings.SplitN(cursor, "|", 2)
		if len(parts) == 2 {
			query = query.Where("(deleted_at < ?) OR (deleted_at = ? AND id < ?)", parts[0], parts[0], parts[1])
		} else {
			query = query.Where("deleted_at < ?", cursor)
		}
	}
	var pos []model.RecycleBin
	// 修正点：排序增加 id 作为同秒 tiebreaker，配合 (user_id, deleted_at, id) 索引
	if err := query.Order("deleted_at DESC, id DESC").Limit(limit + 1).Find(&pos).Error; err != nil {
		return nil, "", err
	}
	hasMore := len(pos) > limit
	if hasMore {
		pos = pos[:limit]
	}
	nextCursor := ""
	if len(pos) > 0 {
		last := pos[len(pos)-1]
		nextCursor = last.DeletedAt.Format("2006-01-02 15:04:05") + "|" + fmt.Sprintf("%d", last.ID)
	}
	items := make([]*biz.RecycleItem, len(pos))
	for i := range pos {
		items[i] = toBizRecycleItem(&pos[i])
	}
	return items, nextCursor, nil
}

// Restore 将文件从回收站恢复到原始位置，返回父目录 ID（0=根目录）。
// 修正点：增加条目级锁 + 存在校验，防止与 DeleteForever/CleanExpired 并发。
func (uc *RecycleUsecase) Restore(ctx context.Context, userID uint64, recycleID uint64) (uint64, error) {
	item, err := uc.recycleRepo.FindByID(ctx, recycleID)
	if err != nil {
		return 0, err
	}
	if item.UserID != userID {
		return 0, ErrForbidden // 越权校验
	}
	// 修正点：条目级锁，串行化同一条目的还原 / 永久删除 / 清理
	lockKey := fmt.Sprintf("recycle:item🔒%d", recycleID)
	if uc.locker != nil {
		if err := uc.locker.Lock(ctx, lockKey); err != nil {
			return 0, err
		}
		defer uc.locker.Unlock(ctx, lockKey)
	}
	// 修正点：加锁后二次确认条目仍在（可能已被清理任务删除）
	if _, err := uc.recycleRepo.FindByID(ctx, recycleID); err != nil {
		return 0, err
	}

	var parentID uint64
	if item.ItemType == "file" {
		file, err := uc.fileRepo.FindByID(ctx, item.ItemID)
		if err != nil {
			return 0, err
		}
		file.Status = 0
		if err := uc.fileRepo.Update(ctx, file); err != nil {
			return 0, err
		}
		if file.ParentID != nil {
			parentID = *file.ParentID
		}
		uc.invalidateFileListCache(ctx, userID)
		if uc.cache != nil {
			_ = uc.cache.Delete(ctx, fmt.Sprintf("file:meta:%d", item.ItemID))
		}
	} else if item.ItemType == "folder" {
		folderID := item.ItemID
		var folderParentID *uint64
		if item.OriginalPath != "" && item.OriginalPath != "0" {
			var pid uint64
			if _, err := fmt.Sscanf(item.OriginalPath, "%d", &pid); err == nil && pid > 0 {
				folderParentID = &pid
				parentID = pid
			}
		}
		// 修正点：目标目录可能已存在同名文件夹，需检测冲突，重命名或返回冲突而非裸报错
		if conflict, _ := uc.folderRepo.FindByNameAndParent(ctx, userID, item.Name, folderParentID); conflict != nil && conflict.ID != folderID {
			item.Name = uniqueName(item.Name, map[string]bool{conflict.Name: true})
		}
		folderUUID, _ := newUUID()
		folder := &Folder{ID: folderID, UUID: folderUUID, UserID: userID, Name: item.Name, ParentID: folderParentID}
		if _, err := uc.folderRepo.Create(ctx, folder); err != nil {
			return 0, err
		}
		trashedFiles, _, _ := uc.fileRepo.ListByParent(ctx, userID, &folderID, 1, "", 100000, "", "")
		if len(trashedFiles) > 0 {
			ids := make([]uint64, len(trashedFiles))
			for i, f := range trashedFiles {
				ids[i] = f.ID
			}
			_ = uc.fileRepo.BatchUpdateStatus(ctx, ids, 0)
		}
		uc.invalidateFileListCache(ctx, userID)
	}

	if err := uc.recycleRepo.Delete(ctx, recycleID); err != nil {
		return 0, err
	}
	return parentID, nil // 配额无需回加：Trash 阶段从未扣减
}

// DeleteForever 永久删除：校验归属 → 条目级锁 → 二次存在校验 → 物理删盘+改库+扣配额。
func (uc *RecycleUsecase) DeleteForever(ctx context.Context, userID uint64, recycleID uint64) error {
	item, err := uc.recycleRepo.FindByID(ctx, recycleID)
	if err != nil {
		return err
	}
	if item.UserID != userID {
		return ErrForbidden // 越权校验：禁止删除他人回收站条目
	}
	// 修正点：条目级分布式锁，与 Restore / CleanExpired 串行化
	lockKey := fmt.Sprintf("recycle:item🔒%d", recycleID)
	if uc.locker != nil {
		if err := uc.locker.Lock(ctx, lockKey); err != nil {
			return err
		}
		defer uc.locker.Unlock(ctx, lockKey)
	}
	// 修正点：加锁后再次确认条目仍在，若已被清理任务删除则直接返回（避免双扣配额）
	if _, err := uc.recycleRepo.FindByID(ctx, recycleID); err != nil {
		return err
	}

	deletedFileIDs := uc.permanentlyDeleteItem(ctx, userID, item)

	if uc.eventPublisher != nil && len(deletedFileIDs) > 0 {
		_ = uc.eventPublisher.Publish(ctx, EventFileDeleted, &FileChangedPayload{
			UserID: userID, FileIDs: deletedFileIDs, Action: "deleted",
		})
	}
	return uc.recycleRepo.Delete(ctx, recycleID)
}

// permanentlyDeleteItem 永久删除单个回收站项目对应的文件记录与磁盘文件。
// 修正点：配额准确性优先——删盘尽力、改库、扣配额；顺序保证"磁盘删失败也不漏扣配额"。
func (uc *RecycleUsecase) permanentlyDeleteItem(ctx context.Context, userID uint64, item *RecycleItem) []uint64 {
	deletedFileIDs := make([]uint64, 0)
	if item.ItemType == "file" {
		file, err := uc.fileRepo.FindByID(ctx, item.ItemID)
		if err != nil {
			log.Warn("recycle: file not found for permanent delete", "id", item.ItemID, "err", err)
			return deletedFileIDs
		}
		// 1) 物理删盘（OSS Delete 幂等；失败仅记日志，不阻断扣减）
		if err := uc.storage.Delete(ctx, file.Path); err != nil {
			log.Error("recycle: failed to delete physical file", "path", file.Path, "err", err)
		}
		// 2) 改库 status=2
		if err := uc.fileRepo.BatchUpdateStatus(ctx, []uint64{item.ItemID}, 2); err != nil {
			log.Error("recycle: failed to update file status", "id", item.ItemID, "err", err)
		}
		// 3) 原子扣减配额（SubUsedStorage 内部带 user 级锁 + WHERE used_storage>=?，安全且不超卖）
		if uc.userUC != nil {
			if err := uc.userUC.SubUsedStorage(ctx, userID, file.Size); err != nil {
				log.Error("recycle: failed to subtract storage", "userID", userID, "err", err)
			}
		}
		deletedFileIDs = append(deletedFileIDs, item.ItemID)
	} else if item.ItemType == "folder" {
		folderID := item.ItemID
		trashedFiles, _, _ := uc.fileRepo.ListByParent(ctx, userID, &folderID, 1, "", 100000, "", "")
		for _, f := range trashedFiles {
			if err := uc.storage.Delete(ctx, f.Path); err != nil {
				log.Error("recycle: failed to delete physical file", "path", f.Path, "err", err)
			}
			if err := uc.fileRepo.BatchUpdateStatus(ctx, []uint64{f.ID}, 2); err != nil {
				log.Error("recycle: failed to update file status", "id", f.ID, "err", err)
			}
			if uc.userUC != nil {
				if err := uc.userUC.SubUsedStorage(ctx, userID, f.Size); err != nil {
					log.Error("recycle: failed to subtract storage", "userID", userID, "err", err)
				}
			}
			deletedFileIDs = append(deletedFileIDs, f.ID)
		}
	}
	if uc.cache != nil {
		for _, fid := range deletedFileIDs {
			_ = uc.cache.Delete(ctx, fmt.Sprintf("file:meta:%d", fid))
		}
	}
	return deletedFileIDs
}

// EmptyRecycle 永久删除用户的所有回收站项目（修正点：分批游标，避免一次性全量）
func (uc *RecycleUsecase) EmptyRecycle(ctx context.Context, userID uint64) error {
	const batchSize = 500
	var cursor string
	deletedFileIDs := make([]uint64, 0)
	for {
		// 修正点：用 keyset 游标分批拉取，而非一次性 LIMIT 100000
		items, next, err := uc.recycleRepo.ListByUser(ctx, userID, cursor, batchSize)
		if err != nil {
			return err
		}
		if len(items) == 0 {
			break
		}
		batchIDs := make([]uint64, 0, len(items))
		for _, item := range items {
			ids := uc.permanentlyDeleteItem(ctx, userID, item)
			deletedFileIDs = append(deletedFileIDs, ids...)
			batchIDs = append(batchIDs, item.ID)
		}
		// 修正点：批量删除回收站记录，减少 SQL 往返
		if err := uc.recycleRepo.DeleteBatch(ctx, batchIDs); err != nil {
			log.Error("recycle: failed to delete recycle items batch", "err", err)
		}
		if !strings.Contains(next, "|") {
			break // 兼容旧游标格式时及时终止
		}
		cursor = next
		if len(items) < batchSize {
			break
		}
	}
	if uc.eventPublisher != nil && len(deletedFileIDs) > 0 {
		_ = uc.eventPublisher.Publish(ctx, EventFileDeleted, &FileChangedPayload{
			UserID: userID, FileIDs: deletedFileIDs, Action: "deleted",
		})
	}
	return nil
}

// EmptyRecycle 永久删除当前用户回收站中的所有项目。
func (s *RecycleService) EmptyRecycle(ctx context.Context, req *v1.EmptyRecycleRequest) (*v1.EmptyRecycleReply, error) {
	userID := CtxUserID(ctx)
	if userID == 0 {
		return nil, biz.ErrInvalidToken
	}
	if err := s.uc.EmptyRecycle(ctx, userID); err != nil {
		return nil, err
	}
	return &v1.EmptyRecycleReply{}, nil
}

// CleanExpired 删除已过期的回收站项目，由 cron 任务调用。
// 修正点：全局锁防止多副本重复执行；分批扫描避免一次载入海量记录。
func (uc *RecycleUsecase) CleanExpired(ctx context.Context) error {
	// 修正点：全局锁，多副本只跑一个
	cleanLock := "recycle:clean:lock"
	if uc.locker != nil {
		if err := uc.locker.Lock(ctx, cleanLock); err != nil {
			log.Warn("recycle: clean locked by another instance, skip", "err", err)
			return nil
		}
		defer uc.locker.Unlock(ctx, cleanLock)
	}

	deletedByUser := make(map[uint64][]uint64)
	const batch = 1000
	for {
		// 修正点：分批拉取过期记录，而非一次性 Find 全表
		expired, hasMore, err := uc.recycleRepo.ListExpiredBatch(ctx, time.Now(), batch)
		if err != nil {
			return err
		}
		for _, item := range expired {
			// 条目级锁在 permanentlyDeleteItem 上游（此处直接用内部删除，需自行加锁）
			lockKey := fmt.Sprintf("recycle:item🔒%d", item.ID)
			if uc.locker != nil {
				if err := uc.locker.Lock(ctx, lockKey); err == nil {
					ids := uc.permanentlyDeleteItem(ctx, item.UserID, item)
					_ = uc.locker.Unlock(ctx, lockKey)
					if len(ids) > 0 {
						deletedByUser[item.UserID] = append(deletedByUser[item.UserID], ids...)
					}
					if err := uc.recycleRepo.Delete(ctx, item.ID); err != nil {
						log.Error("recycle: failed to delete expired item", "id", item.ID, "err", err)
					}
				}
			} else {
				ids := uc.permanentlyDeleteItem(ctx, item.UserID, item)
				if len(ids) > 0 {
					deletedByUser[item.UserID] = append(deletedByUser[item.UserID], ids...)
				}
				_ = uc.recycleRepo.Delete(ctx, item.ID)
			}
		}
		if !hasMore {
			break
		}
	}

	if uc.eventPublisher != nil {
		for userID, fileIDs := range deletedByUser {
			_ = uc.eventPublisher.Publish(ctx, EventFileDeleted, &FileChangedPayload{
				UserID: userID, FileIDs: fileIDs, Action: "deleted",
			})
		}
	}
	return nil
}

// ListExpiredBatch 分批拉取过期记录（修正点：带 Limit，避免全表载入）
func (r *recycleRepo) ListExpiredBatch(ctx context.Context, before time.Time, limit int) ([]*biz.RecycleItem, bool, error) {
	var pos []model.RecycleBin
	if err := r.db.WithContext(ctx).
		Where("expire_at < ?", before).
		Order("expire_at ASC, id ASC").
		Limit(limit + 1).
		Find(&pos).Error; err != nil {
		return nil, false, err
	}
	hasMore := len(pos) > limit
	if hasMore {
		pos = pos[:limit]
	}
	items := make([]*biz.RecycleItem, len(pos))
	for i := range pos {
		items[i] = toBizRecycleItem(&pos[i])
	}
	return items, hasMore, nil
}