import axios from 'axios'
import request from '@/utils/request'
import { localStorage } from '@/utils/local-storage'

/** 京东 BFF：与 agent 对话页同构接口，路径前缀为 /jd */
const PREFIX = 'jd'

function buildApiUrl(path: string) {
  const base = String(process.env.VUE_APP_API_BASE_URL || '/api/').replace(/\/+$/, '')
  return `${base}/${String(path).replace(/^\/+/, '')}`
}

function buildAuthHeaders() {
  const headers: Record<string, string> = {
    'Content-Type': 'application/json',
  }
  const code = localStorage.get('code')
  const userId = localStorage.get('userId')
  if (code) headers.Authorization = String(code)
  if (userId) headers.Userid = String(userId)
  return headers
}

function asRecord(value: unknown) {
  return value && typeof value === 'object' && !Array.isArray(value)
    ? (value as Record<string, unknown>)
    : null
}

function textOf(value: unknown) {
  return value == null ? '' : String(value)
}

function listOf(value: unknown) {
  return Array.isArray(value) ? value : []
}

function asCount(value: unknown) {
  const number = Number(value)
  return Number.isFinite(number) ? number : 0
}

export function normalizeOssUrl(url: string) {
  if (!url) return ''
  let s = String(url).replace(/\\u0026/gi, '&').replace(/\\u003d/gi, '=').trim()
  if (s.indexOf('//') === 0) s = `https:${s}`
  if (/^http:\/\//i.test(s)) s = `https://${s.slice(7)}`
  return s
}

function imageUrlOf(item: Record<string, unknown>) {
  return normalizeOssUrl(
    textOf(item.url || item.file_url || item.image_url || item.cover_url || item.result_url),
  )
}

function guessContentType(file: File | Blob, filename?: string) {
  if (file.type) return file.type
  const name = String(filename || '').toLowerCase()
  if (name.endsWith('.png')) return 'image/png'
  if (name.endsWith('.webp')) return 'image/webp'
  if (name.endsWith('.gif')) return 'image/gif'
  return 'image/jpeg'
}

function guessFilename(file?: File) {
  if (file && (file as File).name) return (file as File).name
  return 'photo.jpg'
}

function formatClock(value: unknown) {
  const n = asCount(value)
  if (!n) {
    const s = textOf(value)
    if (/^\d{1,2}:\d{2}$/.test(s)) return s
    return ''
  }
  const ms = n > 1e12 ? n : n * 1000
  const d = new Date(ms)
  if (Number.isNaN(d.getTime())) return ''
  const h = String(d.getHours()).padStart(2, '0')
  const m = String(d.getMinutes()).padStart(2, '0')
  return `${h}:${m}`
}

// ---------- 类型（对齐 agent-api） ----------

export type UploadPurpose = 'origin' | 'external_effect'
export type ImageGenStatusCode = 'pending' | 'processing' | 'success' | 'failed'

export interface UploadTicket {
  upload_id: string
  upload_url: string
  file_url: string
  content_type: string
  expire_at: number
}

export interface ImageGenSubmitInput {
  session_id: string
  /** 导入生图传 upload_id；编辑效果图不传 */
  upload_id?: string
  /** 编辑效果图传 image_id；导入生图不传 */
  image_id?: string
  prompt?: string
  scene_prop?: string
  custom_text?: string
  /** 效果图编辑 edit；原图编辑 / 普通立即生成 generate */
  mode?: 'generate' | 'edit'
}

export interface ImageGenImage {
  image_id: string
  path: string
  url: string
  index: number
}

export interface ImageGenTask {
  task_id: string
  status: ImageGenStatusCode
}

export interface ImageGenStatus {
  task_id: string
  status: ImageGenStatusCode
  error: string
  style: string
  prompt: string
  images: ImageGenImage[]
}

export interface EffectSubmitInput {
  session_id: string
  upload_id: string
  product_id: number
  product_name?: string
  user_message?: string
  mounts_id?: number
  scene_prop?: string
  custom_text?: string
  base_type?: number
  frame_type?: number
  mount_id?: number
  pid?: number
  proportion_id?: number
  pose_id?: number
  style_id?: number
  prompt?: string
}

export interface EffectSubmitResult {
  task_id: string
  status: ImageGenStatusCode
  error: string
  image_id: string
  url: string
  images: ImageGenImage[]
}

export interface OrderConfirmInput {
  task_id: string
  image_id?: string
  cate_id: number
  product_id?: number
  top_prod_id?: number
  shop_id: number
  print_size?: number
  quantity?: number
  contact_name?: string
  contact_mobile?: string
  address?: string
  country_id?: number
  province_id?: string
  city_id?: string
  county_id?: string
  figure_type: number
  check_id?: number
  out_trade_no?: string
  remark?: string
  shape_id?: number
  font_id?: number
  custom_text?: string
  back_text?: string
  up_text?: string
  down_text?: string
}

export interface OrderConfirmResult {
  order_id: number
  pid: number
  message: string
  out_trade_no?: string
}

export interface SessionDetailUpload {
  upload_id: string
  status: string
  purpose: UploadPurpose | ''
  path: string
  url: string
}

export interface SessionDetailImage {
  image_id: string
  path: string
  url: string
  index: number
}

export interface SessionDetailTask {
  task_id: string
  upload_id: string
  status: string
  error: string
  source: string
  provider: string
  product_name: string
  style_code: string
  style_name: string
  prompt: string
  n: number
  pid: number
  /** generate | edit，编辑效果图时右侧气泡只展示提示词 */
  mode: 'generate' | 'edit' | ''
  created_at: number
  completed_at: number
  duration: number
  images: SessionDetailImage[]
}

export const SESSION_RECORD_TYPES = [
  'session_created',
  'upload',
  'upload_confirmed',
  'imagegen_submit',
  'imagegen_success',
  'imagegen_failed',
  'external_effect',
  'order',
] as const

export type SessionRecordType = (typeof SESSION_RECORD_TYPES)[number]

export interface SessionDetailRecord {
  type: SessionRecordType | ''
  at: number
  message: string
  upload_id: string
  task_id: string
  status: string
  product_name: string
  image_count: number
}

export interface SessionDetail {
  session_id: string
  shop_id: number
  customer_name: string
  subtitle: string
  created_at: number
  updated_at: number
  uploads: SessionDetailUpload[]
  tasks: SessionDetailTask[]
  records: SessionDetailRecord[]
}

export type SessionHistoryItem =
  | {
      role: 'user'
      text: string
      image?: string
      time?: string
      taskId?: string
      uploadId?: string
    }
  | {
      role: 'agent'
      type: 'result'
      image: string
      meta?: string
      time?: string
      durationSec?: number
      taskId?: string
      imageId?: string
      uploadId?: string
      prompt?: string
    }

export function isExternalEffect(value: string | undefined) {
  return value === 'external_effect'
}

// ---------- 解析 ----------

function uploadPurpose(value: unknown): UploadPurpose | '' {
  return value === 'origin' || value === 'external_effect' ? value : ''
}

function sessionRecordType(value: unknown): SessionRecordType | '' {
  const text = textOf(value).trim().toLowerCase()
  return (SESSION_RECORD_TYPES as readonly string[]).includes(text)
    ? (text as SessionRecordType)
    : ''
}

function normalizeDetailImage(raw: unknown): SessionDetailImage | null {
  const item = asRecord(raw)
  if (!item) return null
  const url = imageUrlOf(item)
  if (!url) return null
  return {
    image_id: textOf(item.image_id || item.id),
    path: textOf(item.path),
    url,
    index: asCount(item.index),
  }
}

function normalizeDetailTask(raw: unknown): SessionDetailTask | null {
  const item = asRecord(raw)
  if (!item || !item.task_id) return null
  const images = listOf(item.images ?? item.image_list ?? item.results)
    .map((image) => normalizeDetailImage(image))
    .filter((image): image is SessionDetailImage => Boolean(image))
    .sort((a, b) => a.index - b.index)
  if (!images.length) {
    const url = imageUrlOf(item)
    if (url) {
      images.push({
        image_id: textOf(item.image_id || item.id),
        path: textOf(item.path),
        url,
        index: 0,
      })
    }
  }
  const modeRaw = textOf(item.mode || item.image_gen_mode || item.imageGenMode).toLowerCase()
  const mode: SessionDetailTask['mode'] =
    modeRaw === 'edit' || modeRaw === 'generate' ? modeRaw : ''
  return {
    task_id: textOf(item.task_id),
    upload_id: textOf(item.upload_id),
    status: textOf(item.status),
    error: textOf(item.error || item.message),
    source: textOf(item.source),
    provider: textOf(item.provider),
    product_name: textOf(item.product_name),
    style_code: textOf(item.style_code),
    style_name: textOf(item.style_name),
    prompt: textOf(item.prompt),
    n: asCount(item.n),
    pid: asCount(item.pid),
    mode,
    created_at: asCount(item.created_at),
    completed_at: asCount(item.completed_at),
    duration: asCount(item.duration),
    images,
  }
}

function normalizeDetailRecord(raw: unknown): SessionDetailRecord | null {
  const item = asRecord(raw)
  if (!item) return null
  return {
    type: sessionRecordType(item.type),
    at: asCount(item.at),
    message: textOf(item.message),
    upload_id: textOf(item.upload_id),
    task_id: textOf(item.task_id),
    status: textOf(item.status),
    product_name: textOf(item.product_name),
    image_count: asCount(item.image_count),
  }
}

/** 解析 session/detail（对齐 agent normalizeSessionDetail） */
export function normalizeSessionDetail(data: unknown): SessionDetail {
  const record = asRecord(data) || {}
  const uploads = listOf(record.uploads)
    .map((item) => asRecord(item))
    .filter((item): item is Record<string, unknown> => Boolean(item && item.upload_id))
    .map((item) => ({
      upload_id: textOf(item.upload_id),
      status: textOf(item.status),
      purpose: uploadPurpose(item.purpose),
      path: textOf(item.path),
      url: normalizeOssUrl(textOf(item.url)),
    }))
  const tasks = listOf(record.tasks)
    .map((item) => normalizeDetailTask(item))
    .filter((item): item is SessionDetailTask => Boolean(item))
    .sort((a, b) => a.created_at - b.created_at)
  const records = listOf(record.records)
    .map((item) => normalizeDetailRecord(item))
    .filter((item): item is SessionDetailRecord => Boolean(item))
    .sort((a, b) => a.at - b.at)
  return {
    session_id: textOf(record.session_id),
    shop_id: asCount(record.shop_id),
    customer_name: textOf(record.customer_name),
    subtitle: textOf(record.subtitle),
    created_at: asCount(record.created_at),
    updated_at: asCount(record.updated_at || record.created_at),
    uploads,
    tasks,
    records,
  }
}

function uploadOf(detail: SessionDetail, uploadId: string) {
  return uploadId ? detail.uploads.find((item) => item.upload_id === uploadId) : undefined
}

function isBroughtTask(detail: SessionDetail, task: SessionDetailTask) {
  const upload = uploadOf(detail, task.upload_id)
  return (
    isExternalEffect(upload?.purpose) ||
    isExternalEffect(task.source) ||
    task.provider === 'user_effect'
  )
}

/**
 * 将 session/detail 转为对话气泡历史（对齐 agent applySessionDetail → turns）
 */
export function sessionDetailToHistory(detail: SessionDetail): SessionHistoryItem[] {
  const history: SessionHistoryItem[] = []
  const defaultPrompt = '按所选产品、风格生成手办效果图～'

  detail.tasks.forEach((task) => {
    const upload = uploadOf(detail, task.upload_id)
    const photo = upload?.url || ''
    const brought = isBroughtTask(detail, task)
    const time = formatClock(task.completed_at || task.created_at)
    const seconds =
      task.duration > 0
        ? task.duration
        : task.completed_at > task.created_at
          ? task.completed_at - task.created_at
          : 0
    const images = task.images.filter((image) => image.url)
    const resultImages =
      images.length > 0
        ? images
        : brought && photo
          ? [{ image_id: '', path: '', url: photo, index: 0 }]
          : []

    if (!resultImages.length && task.status !== 'success') return

    // 右侧气泡：purpose=origin 显示原图；external_effect 只展示提示词
    const userImage = upload?.purpose === 'origin' && photo ? photo : undefined
    const userText =
      task.prompt ||
      (brought || upload?.purpose === 'external_effect'
        ? '这是我在别的平台生成的卡通效果图，不用再调整了，直接帮我下单吧～'
        : defaultPrompt)

    history.push({
      role: 'user',
      text: userText,
      image: userImage,
      time: time || undefined,
      taskId: task.task_id,
      uploadId: task.upload_id,
    })

    resultImages.forEach((image) => {
      history.push({
        role: 'agent',
        type: 'result',
        image: image.url,
        time: time || undefined,
        durationSec: seconds,
        meta: time
          ? `${time}${seconds > 0 ? ` · 生图用时 ${seconds}s` : ''}`
          : seconds > 0
            ? `生图用时 ${seconds}s`
            : '',
        taskId: task.task_id,
        imageId: image.image_id || undefined,
        uploadId: task.upload_id,
        prompt: task.prompt || undefined,
      })
    })
  })

  return history
}

/** 兼容旧调用：解析 detail 并产出 history */
export function parseSessionDetail(res: any): SessionDetail & {
  sessionId: string
  history: SessionHistoryItem[]
  raw: any
} {
  const detail = normalizeSessionDetail(res)
  return {
    ...detail,
    sessionId: detail.session_id,
    history: sessionDetailToHistory(detail),
    raw: res,
  }
}

/** 将接口 body 归一成对象（后端若返回 text/plain，axios 会得到 JSON 字符串） */
function coerceResponseBody(res: unknown): Record<string, any> {
  if (res == null) return {}
  if (typeof res === 'string') {
    const text = res.replace(/^\uFEFF/, '').trim()
    if (!text) return {}
    try {
      const parsed = JSON.parse(text)
      return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
        ? (parsed as Record<string, any>)
        : {}
    } catch {
      const start = text.indexOf('{')
      const end = text.lastIndexOf('}')
      if (start >= 0 && end > start) {
        try {
          const parsed = JSON.parse(text.slice(start, end + 1))
          return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
            ? (parsed as Record<string, any>)
            : {}
        } catch {
          return {}
        }
      }
      return {}
    }
  }
  if (typeof res === 'object' && !Array.isArray(res)) return res as Record<string, any>
  return {}
}

/** 从 upload/url 业务体提取票据（兼容整包 / 已解包 / JSON 字符串） */
export function parseUploadUrlResult(res: any): UploadTicket {
  const root = coerceResponseBody(res)
  // 优先整包 { code, data: { upload_id, upload_url } }
  const fromEnvelope =
    root.data && typeof root.data === 'object' && !Array.isArray(root.data)
      ? (root.data as Record<string, any>)
      : null
  const data =
    fromEnvelope && (fromEnvelope.upload_id || fromEnvelope.uploadId || fromEnvelope.upload_url)
      ? fromEnvelope
      : root
  return {
    upload_id: textOf(data.upload_id || data.uploadId),
    upload_url: normalizeOssUrl(
      textOf(data.upload_url || data.uploadUrl || data.put_url || data.putUrl),
    ),
    file_url: normalizeOssUrl(textOf(data.file_url || data.fileUrl)),
    content_type: textOf(data.content_type || data.contentType) || 'image/jpeg',
    expire_at: asCount(data.expire_at || data.expireAt),
  }
}

function normalizeImageGenStatus(data: unknown, taskId: string): ImageGenStatus {
  const record = asRecord(data) || {}
  const images = listOf(record.images ?? record.image_list ?? record.results)
    .map((item) => normalizeDetailImage(item))
    .filter((item): item is SessionDetailImage => Boolean(item))
    .map((item) => ({
      image_id: item.image_id,
      path: item.path,
      url: item.url,
      index: item.index,
    }))
  if (!images.length) {
    const url = imageUrlOf(record)
    if (url) {
      images.push({
        image_id: textOf(record.image_id || record.id),
        path: textOf(record.path),
        url,
        index: 0,
      })
    }
  }
  const statusText = textOf(record.status).toLowerCase()
  const status: ImageGenStatusCode =
    statusText === 'pending' ||
    statusText === 'processing' ||
    statusText === 'success' ||
    statusText === 'failed'
      ? statusText
      : images.length
        ? 'success'
        : 'pending'
  return {
    task_id: textOf(record.task_id) || taskId,
    status,
    error: textOf(record.error),
    style: textOf(record.style),
    prompt: textOf(record.prompt),
    images,
  }
}

/** 兼容旧 parseImageGenStatus 调用 */
export function parseImageGenStatus(res: any, taskId = '') {
  const normalized = normalizeImageGenStatus(res, taskId)
  const first = normalized.images[0]
  return {
    taskId: normalized.task_id,
    status: normalized.status,
    done: normalized.status === 'success' || Boolean(first?.url),
    failed: normalized.status === 'failed',
    resultUrl: first?.url || '',
    imageId: first?.image_id || '',
    images: normalized.images,
    error: normalized.error,
    raw: res,
  }
}

function normalizeEffectSubmit(data: unknown): EffectSubmitResult {
  const record = asRecord(data) || {}
  const images = listOf(record.images)
    .map((item) => normalizeDetailImage(item))
    .filter((item): item is SessionDetailImage => Boolean(item))
    .map((item) => ({
      image_id: item.image_id,
      path: item.path,
      url: item.url,
      index: item.index,
    }))
  const statusText = textOf(record.status)
  const status: ImageGenStatusCode =
    statusText === 'pending' ||
    statusText === 'processing' ||
    statusText === 'success' ||
    statusText === 'failed'
      ? statusText
      : 'success'
  return {
    task_id: textOf(record.task_id),
    status,
    error: textOf(record.error),
    image_id: textOf(record.image_id) || images[0]?.image_id || '',
    url:
      normalizeOssUrl(textOf(record.url || record.file_url || record.effect_url)) ||
      images[0]?.url ||
      '',
    images,
  }
}

// ---------- 接口（参数对齐 agent-api，路径用 /jd） ----------

/** GET /jd/session/detail?session_id= */
export const getSessionDetail = (params: { session_id: string } | Record<string, any>) => {
  const sessionId =
    typeof params === 'object' && params
      ? textOf((params as any).session_id).trim()
      : ''
  return request(`${PREFIX}/session/detail`, {
    method: 'GET',
    params: {
      ...params,
      session_id: sessionId || textOf((params as any)?.session_id),
    },
  }).then((res) => normalizeSessionDetail(res))
}

/** GET /jd/session/images */
export const getSessionImages = (query: {
  shop_id?: number
  session_id?: string
  order?: 'asc' | 'desc'
  page?: number
  size?: number
} = {}) => {
  const params: Record<string, any> = {
    page: query.page && query.page > 0 ? query.page : 1,
    size: Math.min(100, Math.max(1, query.size || 20)),
  }
  if (query.shop_id) params.shop_id = query.shop_id
  if (query.session_id?.trim()) params.session_id = query.session_id.trim()
  if (query.order === 'asc' || query.order === 'desc') params.order = query.order
  return request(`${PREFIX}/session/images`, {
    method: 'GET',
    params,
  })
}

/**
 * POST /jd/upload/url
 * 使用独立 axios（不走全局 response 拦截器），直接读 response.data
 */
export const getUploadUrl = async (input: {
  session_id: string
  filename?: string
  content_type?: string
  purpose?: UploadPurpose
}): Promise<UploadTicket> => {
  const response = await axios.post(
    buildApiUrl(`${PREFIX}/upload/url`),
    {
      session_id: input.session_id,
      filename: input.filename || '',
      content_type: input.content_type || 'image/jpeg',
      purpose: input.purpose || 'origin',
    },
    {
      headers: buildAuthHeaders(),
      timeout: 30000,
    },
  )

  // 注意：若 Content-Type 不是 application/json，axios 会把 body 留成 string
  const ticket = parseUploadUrlResult(response?.data)

  if (!ticket.upload_id) {
    throw new Error('签发上传地址失败：缺少 upload_id')
  }
  if (!ticket.upload_url) {
    throw new Error('签发上传地址失败：缺少 upload_url')
  }
  return ticket
}

/** PUT OSS */
export async function putUpload(uploadUrl: string, file: Blob, contentType: string) {
  const response = await fetch(uploadUrl, {
    method: 'PUT',
    headers: contentType ? { 'Content-Type': contentType } : undefined,
    body: file,
  })
  if (!response.ok) throw new Error('图片上传失败')
}

/** POST /jd/upload/confirm */
export const confirmUpload = (input: { session_id: string; upload_id: string }) => {
  return request(`${PREFIX}/upload/confirm`, {
    method: 'POST',
    data: {
      session_id: input.session_id,
      upload_id: input.upload_id,
    },
  })
}

/**
 * POST /jd/subject/classify
 * 图片上传完成后识别主体（session_id + upload_id）
 */
export const classifySubject = (input: {
  session_id: string
  upload_id: string
}) => {
  return request('jd/subject/classify', {
    method: 'POST',
    data: {
      session_id: input.session_id,
      upload_id: input.upload_id,
    },
  })
}

/** POST /jd/imagegen/submit */
export const submitImageGen = (input: ImageGenSubmitInput) => {
  const data: Record<string, string> = {
    session_id: input.session_id,
    prompt: input.prompt || '',
    scene_prop: input.scene_prop || '',
    custom_text: input.custom_text || '',
    mode: input.mode || 'generate',
  }
  const uploadId = String(input.upload_id || '').trim()
  const imageId = String(input.image_id || '').trim()
  // 导入生图：upload_id；编辑效果图：image_id（互斥）
  if (uploadId) data.upload_id = uploadId
  if (imageId) data.image_id = imageId
  return request(`${PREFIX}/imagegen/submit`, {
    method: 'POST',
    data,
  }) as Promise<ImageGenTask>
}

/** POST /jd/effect/submit */
export const submitExternalEffect = (input: EffectSubmitInput) => {
  return request(`${PREFIX}/effect/submit`, {
    method: 'POST',
    data: {
      session_id: input.session_id,
      upload_id: input.upload_id,
      product_id: input.product_id,
      product_name: input.product_name || '',
      user_message: input.user_message || '',
      mounts_id: input.mounts_id ?? 0,
      scene_prop: input.scene_prop || '',
      custom_text: input.custom_text || '',
      base_type: input.base_type ?? 0,
      frame_type: input.frame_type ?? 0,
      mount_id: input.mount_id ?? 0,
      pid: input.pid ?? 0,
      proportion_id: input.proportion_id ?? 0,
      pose_id: input.pose_id ?? 0,
      style_id: input.style_id ?? 0,
      prompt: input.prompt || '',
    },
  }).then(normalizeEffectSubmit)
}

/** GET /jd/imagegen/status?task_id= */
export const getImageGenStatus = (taskId: string) => {
  return request(`${PREFIX}/imagegen/status`, {
    method: 'GET',
    params: { task_id: taskId },
  }).then((data) => normalizeImageGenStatus(data, taskId))
}

/** POST /jd/order/confirm */
export const confirmOrder = (input: OrderConfirmInput) => {
  const shapeId = input.shape_id ?? 0
  return request(`${PREFIX}/order/confirm`, {
    method: 'POST',
    data: {
      ...input,
      top_prod_id: input.top_prod_id ?? shapeId ?? 0,
      shape_id: shapeId,
      font_id: input.font_id ?? 0,
      custom_text: input.custom_text || '',
      back_text: input.back_text || '',
      up_text: input.up_text || '',
      down_text: input.down_text || '',
      check_id: input.check_id ?? 0,
      country_id: input.country_id ?? 45,
      province_id: input.province_id || '',
      city_id: input.city_id || '',
      county_id: input.county_id || '',
    },
  }) as Promise<OrderConfirmResult>
}

/**
 * 导入阶段：签发 URL → PUT OSS（不 confirm）
 * 拿到 upload_id 后可立刻调 subject/classify
 */
export async function prepareUpload(
  file: File | Blob,
  options: {
    session_id: string
    filename?: string
    purpose?: UploadPurpose
  },
) {
  const name = options.filename || guessFilename(file as File)
  const contentType = guessContentType(file, name)
  const ticket = await getUploadUrl({
    session_id: options.session_id,
    filename: name,
    content_type: contentType,
    purpose: options.purpose || 'origin',
  })
  await putUpload(ticket.upload_url, file, ticket.content_type || contentType)
  return {
    uploadId: ticket.upload_id,
    fileUrl: ticket.file_url,
    contentType: ticket.content_type || contentType,
    filename: name,
  }
}

/**
 * 完整上传：签发 URL → PUT OSS → confirm（需 session_id）
 */
export async function uploadOriginal(
  file: File | Blob,
  options: {
    session_id: string
    filename?: string
    purpose?: UploadPurpose
  },
) {
  const prepared = await prepareUpload(file, options)
  await confirmUpload({
    session_id: options.session_id,
    upload_id: prepared.uploadId,
  })
  return prepared
}