Genarrative/src/services/image-editor/editorMediaAssetUploadClient.ts

import { requestJson } from '../apiClient';
import { getSignedAssetReadUrl } from '../assetReadUrlService';

export type EditorMediaAssetUploadType = 'video' | 'audio';

type DirectUploadTicketResponse = {
  upload: {
    bucket: string;
    host: string;
    objectKey: string;
    legacyPublicPath: string;
    formFields: Record<string, string | null | undefined>;
  };
};

type ConfirmAssetObjectResponse = {
  assetObject: {
    assetObjectId: string;
    objectKey: string;
    assetKind: string;
  };
};

export type UploadedEditorMediaAsset = {
  src: string;
  objectKey: string;
  assetObjectId: string;
  legacyPublicPath: string;
};

const EDITOR_MEDIA_READ_EXPIRE_SECONDS = 60 * 60;

function resolveEditorMediaAssetKind(mediaType: EditorMediaAssetUploadType) {
  return mediaType === 'video'
    ? 'editor_uploaded_video'
    : 'editor_uploaded_audio';
}

function resolveFallbackFileName(mediaType: EditorMediaAssetUploadType) {
  return mediaType === 'video' ? 'editor-video.mp4' : 'editor-audio.mp3';
}

function sanitizeEditorMediaFileName(
  fileName: string,
  mediaType: EditorMediaAssetUploadType,
) {
  const trimmedName = fileName.trim();
  return trimmedName || resolveFallbackFileName(mediaType);
}

async function postDirectUploadFile(
  upload: DirectUploadTicketResponse['upload'],
  file: File,
) {
  const formData = new FormData();
  Object.entries(upload.formFields).forEach(([key, value]) => {
    if (value !== null && value !== undefined) {
      formData.append(key, value);
    }
  });
  formData.append('file', file, file.name);

  const response = await fetch(upload.host, {
    method: 'POST',
    body: formData,
  });

  if (!response.ok) {
    throw new Error('上传素材失败');
  }
}

export async function uploadEditorMediaAssetFile(
  file: File,
  mediaType: EditorMediaAssetUploadType,
): Promise<UploadedEditorMediaAsset> {
  const assetKind = resolveEditorMediaAssetKind(mediaType);
  const fileName = sanitizeEditorMediaFileName(file.name, mediaType);
  const contentType = file.type.trim() || 'application/octet-stream';

  const ticket = await requestJson<DirectUploadTicketResponse>(
    '/api/assets/direct-upload-tickets',
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        legacyPrefix: 'generated-character-drafts',
        pathSegments: ['editor', 'asset-library', mediaType, `${Date.now()}`],
        fileName,
        contentType,
        access: 'private',
        maxSizeBytes: file.size,
        successActionStatus: 200,
        metadata: {
          asset_kind: assetKind,
          editor_media_type: mediaType,
        },
      }),
    },
    '创建素材上传凭证失败',
  );

  await postDirectUploadFile(ticket.upload, file);

  const confirmed = await requestJson<ConfirmAssetObjectResponse>(
    '/api/assets/objects/confirm',
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        bucket: ticket.upload.bucket,
        objectKey: ticket.upload.objectKey,
        contentType,
        contentLength: file.size,
        assetKind,
        accessPolicy: 'private',
        entityId: `editor-asset-library-${mediaType}`,
      }),
    },
    '确认素材资产失败',
  );

  // 中文注释：素材库立即预览使用短期 signed URL；持久化仍记录 legacy path 和 objectKey。
  const signedUrl = await getSignedAssetReadUrl(
    {
      objectKey: confirmed.assetObject.objectKey,
      expireSeconds: EDITOR_MEDIA_READ_EXPIRE_SECONDS,
    },
    undefined,
    { bypassCache: true },
  );

  return {
    src: signedUrl,
    objectKey: confirmed.assetObject.objectKey,
    assetObjectId: confirmed.assetObject.assetObjectId,
    legacyPublicPath: ticket.upload.legacyPublicPath,
  };
}