xiaoxia-saas/apps/web/src/pages/assets/hooks/useAssetUpload.ts

import { useState, useCallback, useRef, useEffect } from "react"
import { useQueryClient } from "@tanstack/react-query"
import { message } from "antd"
import { prepareDirectUploadHandle, type DirectUploadHandle } from "@/api/assets"
import { MAX_FILE_SIZE } from "../constants"

/** 单文件上传状态机 */
export type UploadItemStatus = "preparing" | "uploading" | "ingesting" | "done" | "error"

export interface UploadItem {
  /** 前端临时 id（prepare 前无 asset_id 时用） */
  tempId: string
  file: File
  fileName: string
  /** 进度 0~100（仅直传阶段有真实进度） */
  progress: number
  status: UploadItemStatus
  /** 后端 prepare 预建的 asset id（旧后端可能为空） */
  assetId?: string
  /** 去重命中：complete 返回 duplicated，标记完成但不产生新素材 */
  duplicated?: boolean
  error?: string
}

/** 批量直传最大并发数，避免多文件瓜分上行带宽 */
const MAX_CONCURRENT = 3

/**
 * 素材批量上传 Hook
 * - prepare 阶段后端预建 status=uploading 的 asset，前端拿到 asset_id 立即刷新列表
 * - OSS 直传并发限制为 3，其余排队；每个文件独立进度/状态
 * - complete 后素材进入转码（ingesting/processing），由列表轮询反映
 * - 失败卡片支持重试/移除
 */
export function useAssetUpload({ effectiveLibId }: { effectiveLibId: string }) {
  const queryClient = useQueryClient()

  const [items, setItems] = useState<UploadItem[]>([])
  const itemsRef = useRef<UploadItem[]>([])
  itemsRef.current = items

  const updateItem = useCallback((tempId: string, patch: Partial<UploadItem>) => {
    setItems((prev) => prev.map((it) => (it.tempId === tempId ? { ...it, ...patch } : it)))
  }, [])

  /** 刷新素材列表（prepare 后/complete 后调用，让卡片即时出现/流转） */
  const refreshList = useCallback(() => {
    // 使用 refetchQueries 强制立即重新获取，避免 staleTime 导致延迟
    if (effectiveLibId) {
      queryClient.refetchQueries({ queryKey: ["assets", effectiveLibId] })
    }
    queryClient.invalidateQueries({ queryKey: ["asset-libraries"] })
  }, [queryClient, effectiveLibId])

  /** 执行单个文件的完整上传流程（prepare→transfer→complete） */
  const runUpload = useCallback(
    async (item: UploadItem, handle?: DirectUploadHandle) => {
      try {
        // 1. prepare（重试时复用已准备的 handle 也行，但签名可能过期，重新 prepare 最稳）
        const h =
          handle ??
          (await prepareDirectUploadHandle({ file: item.file, library_id: effectiveLibId }))
        if (h.prepared.asset_id) {
          updateItem(item.tempId, {
            status: "uploading",
            assetId: h.prepared.asset_id,
            progress: 0,
          })
          // 预建 asset 已入库，立即刷新让「上传中」卡片出现在网格
          refreshList()
        } else {
          updateItem(item.tempId, { status: "uploading", progress: 0 })
        }

        // 2. OSS 直传（真实进度）
        await h.transfer((pct) => updateItem(item.tempId, { progress: pct }))

        // 3. complete：后端创建 ingest job，素材进入转码
        updateItem(item.tempId, { status: "ingesting", progress: 100 })
        const result = await h.complete()
        refreshList()

        if (result.duplicated) {
          updateItem(item.tempId, { status: "done", duplicated: true, assetId: result.asset_id })
          message.info(`"${item.fileName}" 与素材库已有内容相同，已跳过`)
        } else {
          updateItem(item.tempId, { status: "done" })
          message.success(`"${item.fileName}" 上传完成，正在转码处理`)
        }
      } catch (err: unknown) {
        const detail = err instanceof Error ? err.message : "上传失败"
        console.error("[useAssetUpload] 上传失败:", item.fileName, err)
        updateItem(item.tempId, { status: "error", error: detail })
        message.error(`"${item.fileName}" 上传失败：${detail}`)
      }
    },
    [effectiveLibId, refreshList, updateItem],
  )

  /**
   * 队列调度：把并发槽塞满（同时在途的 prepare+transfer 不超过 MAX_CONCURRENT）。
   * runUpload 在 await prepare 期间 state 仍是 preparing，多个并发 pump 若只看 state
   * 会重复认领同一项，因此用 claimedRef 记录已被认领的 tempId。
   */
  const inFlightRef = useRef(0)
  const claimedRef = useRef<Set<string>>(new Set())
  const pumpRef = useRef<() => void>(() => {})
  pumpRef.current = () => {
    while (inFlightRef.current < MAX_CONCURRENT) {
      const next = itemsRef.current.find(
        (it) => it.status === "preparing" && !claimedRef.current.has(it.tempId),
      )
      if (!next) return
      claimedRef.current.add(next.tempId)
      inFlightRef.current += 1
      void runUpload(next).finally(() => {
        inFlightRef.current -= 1
        claimedRef.current.delete(next.tempId)
        // 一个任务结束（成功/失败）后继续拉起排队任务
        setTimeout(() => pumpRef.current(), 0)
      })
    }
  }

  useEffect(() => {
    pumpRef.current()
  }, [items])

  /** 入队一个或多个文件 */
  const enqueueUploads = useCallback(
    (files: File[]) => {
      if (!effectiveLibId) {
        message.warning("请先选择或创建一个视频库")
        return
      }
      const valid: File[] = []
      for (const file of files) {
        if (file.size > MAX_FILE_SIZE) {
          message.error(`文件 "${file.name}" 超过 2GB 限制`)
          continue
        }
        valid.push(file)
      }
      if (valid.length === 0) return

      const newItems: UploadItem[] = valid.map((file, idx) => ({
        tempId: `${Date.now()}-${idx}-${Math.random().toString(36).slice(2, 8)}`,
        file,
        fileName: file.name,
        progress: 0,
        status: "preparing",
      }))
      setItems((prev) => [...prev, ...newItems])
    },
    [effectiveLibId],
  )

  /** 重试失败任务 */
  const retryUpload = useCallback(
    (tempId: string) => {
      const target = itemsRef.current.find((it) => it.tempId === tempId)
      if (!target) return
      updateItem(tempId, { status: "preparing", progress: 0, error: undefined })
      // 状态更新后由 useEffect 触发 pump
    },
    [updateItem],
  )

  /** 从上传列表移除（已进入转码的由素材网格管理；这里只移除上传面板记录） */
  const removeUpload = useCallback((tempId: string) => {
    setItems((prev) => prev.filter((it) => it.tempId !== tempId))
  }, [])

  /** 清空已完成/去重记录 */
  const clearFinished = useCallback(() => {
    setItems((prev) => prev.filter((it) => it.status !== "done"))
  }, [])

  const activeCount = items.filter(
    (it) => it.status === "preparing" || it.status === "uploading",
  ).length
  const pendingCount = items.filter((it) => it.status === "preparing").length
  const hasActive = activeCount > 0 || items.some((it) => it.status === "ingesting")

  return {
    uploadItems: items,
    enqueueUploads,
    retryUpload,
    removeUpload,
    clearFinished,
    /** 是否有进行中的上传（用于上传区文案） */
    uploading: hasActive,
    activeCount,
    pendingCount,
  }
}