xiaoxia-saas/apps/web/src/api/assets/assets.ts

/**
 * 素材 CRUD API
 */
import apiClient from "../client"
import type { AssetItem, AssetMetadata } from "./types"

/** 获取素材库下的所有素材 */
export const getAssets = async (
  libraryId: string,
  options?: {
    status?: string
    page?: number
    page_size?: number
  },
): Promise<{ items: AssetItem[]; total: number }> => {
  const params: Record<string, string | number> = { library_id: libraryId }
  if (options?.status) params.status = options.status
  if (options?.page) params.page = options.page
  if (options?.page_size) params.page_size = options.page_size
  const response = await apiClient.get("/assets", { params })
  const data = response.data || {}
  const items: AssetItem[] = data.items || []
  const total: number = typeof data.total === "number" ? data.total : items.length
  return { items, total }
}

/** 按类型获取素材（如 voice/video/image），支持可选筛选 */
export const getAssetsByKind = async (
  kind: string,
  filters?: {
    keyword?: string
    gender?: string
    style?: string
    tag_ids?: string[]
    limit?: number
    page?: number
    page_size?: number
  },
): Promise<AssetItem[]> => {
  const params: Record<string, string | number> = { kind }
  if (filters?.keyword) params.keyword = filters.keyword
  if (filters?.gender) params.gender = filters.gender
  if (filters?.style) params.style = filters.style
  if (filters?.tag_ids?.length) params.tag_ids = filters.tag_ids.join(",")
  if (filters?.limit) params.limit = filters.limit
  if (filters?.page) params.page = filters.page
  if (filters?.page_size) params.page_size = filters.page_size
  const response = await apiClient.get("/assets", { params })
  return response.data.items || []
}

/**
 * 智能匹配素材（后端 AI 选素材）
 * 调用后端 smart-match 端点，由后端根据素材库内容智能选择素材
 *
 * 后端返回 items 元素兼容两种结构（过渡期）：
 * - 扁平结构：AssetItem 本身（id 在顶层）
 * - 包装结构：{ asset: AssetItem, score, breakdown }（id 需从 .asset 取）
 * 这里统一归一化为 AssetItem[]，调用方无需关心包装层。
 */
export interface SmartMatchResult {
  items: AssetItem[]
}

interface SmartMatchWrappedItem {
  asset?: AssetItem
  id?: string
  score?: number
  breakdown?: unknown
}

export const smartMatchAssets = async (
  libraryId: string,
  limit?: number,
): Promise<SmartMatchResult> => {
  const payload: Record<string, unknown> = { library_id: libraryId }
  if (limit && limit > 0) payload.limit = limit
  const response = await apiClient.post("/assets/smart-match", payload)
  const rawItems: SmartMatchWrappedItem[] = response.data?.items ?? []
  const items = rawItems
    .map((it) =>
      // 包装结构 { asset: {...} } 优先解包；否则视其本身为扁平 AssetItem
      it?.asset && typeof it.asset === "object" && "id" in it.asset
        ? it.asset
        : (it as unknown as AssetItem),
    )
    .filter((it): it is AssetItem => !!it && typeof it.id === "string" && it.id.length > 0)
  return { items }
}

/** 更新素材（名称、metadata 等） */
export const updateAsset = async (
  assetId: string,
  data: { name?: string; metadata?: AssetMetadata },
): Promise<AssetItem> => {
  const response = await apiClient.put(`/assets/${assetId}`, data)
  return response.data
}

/** 更新素材审核状态 */
export const updateAssetReviewStatus = async (
  assetId: string,
  reviewStatus: "pending_review" | "approved" | "rejected",
): Promise<AssetItem> => {
  const response = await apiClient.patch(`/assets/${assetId}/review`, {
    review_status: reviewStatus,
  })
  return response.data
}

/** 删除素材 */
export const deleteAsset = async (assetId: string): Promise<void> => {
  await apiClient.delete(`/assets/${assetId}`)
}