frontend/src/api/sora.ts

/**
 * Sora 客户端 API
 * 封装所有 Sora 生成、作品库、配额等接口调用
 */

import { apiClient } from './client'

// ==================== 类型定义 ====================

export interface SoraGeneration {
  id: number
  user_id: number
  model: string
  prompt: string
  media_type: string
  status: string // pending | generating | completed | failed | cancelled
  storage_type: string // upstream | s3 | local
  media_url: string
  media_urls: string[]
  s3_object_keys: string[]
  file_size_bytes: number
  error_message: string
  created_at: string
  completed_at?: string
}

export interface GenerateRequest {
  model: string
  prompt: string
  video_count?: number
  media_type?: string
  image_input?: string
  api_key_id?: number
}

export interface GenerateResponse {
  generation_id: number
  status: string
}

export interface GenerationListResponse {
  data: SoraGeneration[]
  total: number
  page: number
}

export interface QuotaInfo {
  quota_bytes: number
  used_bytes: number
  available_bytes: number
  quota_source: string // user | group | system | unlimited
  source?: string // 兼容旧字段
}

export interface StorageStatus {
  s3_enabled: boolean
  s3_healthy: boolean
  local_enabled: boolean
}

/** 单个扁平模型（旧接口，保留兼容） */
export interface SoraModel {
  id: string
  name: string
  type: string // video | image
  orientation?: string
  duration?: number
}

/** 模型家族（新接口 — 后端从 soraModelConfigs 自动聚合） */
export interface SoraModelFamily {
  id: string          // 家族 ID，如 "sora2"
  name: string        // 显示名，如 "Sora 2"
  type: string        // "video" | "image"
  orientations: string[]  // ["landscape", "portrait"] 或 ["landscape", "portrait", "square"]
  durations?: number[]    // [10, 15, 25]（仅视频模型）
}

type LooseRecord = Record<string, unknown>

function asRecord(value: unknown): LooseRecord | null {
  return value !== null && typeof value === 'object' ? value as LooseRecord : null
}

function asArray<T = unknown>(value: unknown): T[] {
  return Array.isArray(value) ? value as T[] : []
}

function asPositiveInt(value: unknown): number | null {
  const n = Number(value)
  if (!Number.isFinite(n) || n <= 0) return null
  return Math.round(n)
}

function dedupeStrings(values: string[]): string[] {
  return Array.from(new Set(values))
}

function extractOrientationFromModelID(modelID: string): string | null {
  const m = modelID.match(/-(landscape|portrait|square)(?:-\d+s)?$/i)
  return m ? m[1].toLowerCase() : null
}

function extractDurationFromModelID(modelID: string): number | null {
  const m = modelID.match(/-(\d+)s$/i)
  return m ? asPositiveInt(m[1]) : null
}

function normalizeLegacyFamilies(candidates: unknown[]): SoraModelFamily[] {
  const familyMap = new Map<string, SoraModelFamily>()

  for (const item of candidates) {
    const model = asRecord(item)
    if (!model || typeof model.id !== 'string' || model.id.trim() === '') continue

    const rawID = model.id.trim()
    const type = model.type === 'image' ? 'image' : 'video'
    const name = typeof model.name === 'string' && model.name.trim() ? model.name.trim() : rawID
    const baseID = rawID.replace(/-(landscape|portrait|square)(?:-\d+s)?$/i, '')
    const orientation =
      typeof model.orientation === 'string' && model.orientation
        ? model.orientation.toLowerCase()
        : extractOrientationFromModelID(rawID)
    const duration = asPositiveInt(model.duration) ?? extractDurationFromModelID(rawID)
    const familyKey = baseID || rawID

    const family = familyMap.get(familyKey) ?? {
      id: familyKey,
      name,
      type,
      orientations: [],
      durations: []
    }

    if (orientation) {
      family.orientations.push(orientation)
    }
    if (type === 'video' && duration) {
      family.durations = family.durations || []
      family.durations.push(duration)
    }

    familyMap.set(familyKey, family)
  }

  return Array.from(familyMap.values())
    .map((family) => ({
      ...family,
      orientations:
        family.orientations.length > 0
          ? dedupeStrings(family.orientations)
          : (family.type === 'image' ? ['square'] : ['landscape']),
      durations:
        family.type === 'video'
          ? Array.from(new Set((family.durations || []).filter((d): d is number => Number.isFinite(d)))).sort((a, b) => a - b)
          : []
    }))
    .filter((family) => family.id !== '')
}

function normalizeModelFamilyRecord(item: unknown): SoraModelFamily | null {
  const model = asRecord(item)
  if (!model || typeof model.id !== 'string' || model.id.trim() === '') return null
  // 仅把明确的“家族结构”识别为 family；老结构（单模型）走 legacy 聚合逻辑。
  if (!Array.isArray(model.orientations) && !Array.isArray(model.durations)) return null

  const orientations = asArray<string>(model.orientations).filter((o): o is string => typeof o === 'string' && o.length > 0)
  const durations = asArray<unknown>(model.durations)
    .map(asPositiveInt)
    .filter((d): d is number => d !== null)

  return {
    id: model.id.trim(),
    name: typeof model.name === 'string' && model.name.trim() ? model.name.trim() : model.id.trim(),
    type: model.type === 'image' ? 'image' : 'video',
    orientations: dedupeStrings(orientations),
    durations: Array.from(new Set(durations)).sort((a, b) => a - b)
  }
}

function extractCandidateArray(payload: unknown): unknown[] {
  if (Array.isArray(payload)) return payload
  const record = asRecord(payload)
  if (!record) return []

  const keys: Array<keyof LooseRecord> = ['data', 'items', 'models', 'families']
  for (const key of keys) {
    if (Array.isArray(record[key])) {
      return record[key] as unknown[]
    }
  }
  return []
}

export function normalizeModelFamiliesResponse(payload: unknown): SoraModelFamily[] {
  const candidates = extractCandidateArray(payload)
  if (candidates.length === 0) return []

  const normalized = candidates
    .map(normalizeModelFamilyRecord)
    .filter((item): item is SoraModelFamily => item !== null)

  if (normalized.length > 0) return normalized
  return normalizeLegacyFamilies(candidates)
}

export function normalizeGenerationListResponse(payload: unknown): GenerationListResponse {
  const record = asRecord(payload)
  if (!record) {
    return { data: [], total: 0, page: 1 }
  }

  const data = Array.isArray(record.data)
    ? (record.data as SoraGeneration[])
    : Array.isArray(record.items)
      ? (record.items as SoraGeneration[])
      : []

  const total = Number(record.total)
  const page = Number(record.page)

  return {
    data,
    total: Number.isFinite(total) ? total : data.length,
    page: Number.isFinite(page) && page > 0 ? page : 1
  }
}

// ==================== API 方法 ====================

/** 异步生成 — 创建 pending 记录后立即返回 */
export async function generate(req: GenerateRequest): Promise<GenerateResponse> {
  const { data } = await apiClient.post<GenerateResponse>('/sora/generate', req)
  return data
}

/** 查询生成记录列表 */
export async function listGenerations(params?: {
  page?: number
  page_size?: number
  status?: string
  storage_type?: string
  media_type?: string
}): Promise<GenerationListResponse> {
  const { data } = await apiClient.get<unknown>('/sora/generations', { params })
  return normalizeGenerationListResponse(data)
}

/** 查询生成记录详情 */
export async function getGeneration(id: number): Promise<SoraGeneration> {
  const { data } = await apiClient.get<SoraGeneration>(`/sora/generations/${id}`)
  return data
}

/** 删除生成记录 */
export async function deleteGeneration(id: number): Promise<{ message: string }> {
  const { data } = await apiClient.delete<{ message: string }>(`/sora/generations/${id}`)
  return data
}

/** 取消生成任务 */
export async function cancelGeneration(id: number): Promise<{ message: string }> {
  const { data } = await apiClient.post<{ message: string }>(`/sora/generations/${id}/cancel`)
  return data
}

/** 手动保存到 S3 */
export async function saveToStorage(
  id: number
): Promise<{ message: string; object_key: string; object_keys?: string[] }> {
  const { data } = await apiClient.post<{ message: string; object_key: string; object_keys?: string[] }>(
    `/sora/generations/${id}/save`
  )
  return data
}

/** 查询配额信息 */
export async function getQuota(): Promise<QuotaInfo> {
  const { data } = await apiClient.get<QuotaInfo>('/sora/quota')
  return data
}

/** 获取可用模型家族列表 */
export async function getModels(): Promise<SoraModelFamily[]> {
  const { data } = await apiClient.get<unknown>('/sora/models')
  return normalizeModelFamiliesResponse(data)
}

/** 获取存储状态 */
export async function getStorageStatus(): Promise<StorageStatus> {
  const { data } = await apiClient.get<StorageStatus>('/sora/storage-status')
  return data
}

const soraAPI = {
  generate,
  listGenerations,
  getGeneration,
  deleteGeneration,
  cancelGeneration,
  saveToStorage,
  getQuota,
  getModels,
  getStorageStatus
}

export default soraAPI