geo/apps/ops-web/src/lib/desktop-client-releases.ts

import { http } from '@/lib/http'

export type DesktopReleasePlatform = 'darwin' | 'win32' | 'linux'
export type DesktopReleaseArch = 'universal' | 'x64' | 'arm64' | 'ia32'
export type DesktopReleaseSource = 'oss' | 'custom'

export interface DesktopClientRelease {
  id: number
  platform: DesktopReleasePlatform
  arch: DesktopReleaseArch
  channel: string
  version: string
  min_supported_version?: string | null
  download_source: DesktopReleaseSource
  oss_object_key?: string | null
  custom_download_url?: string | null
  download_url?: string | null
  file_name?: string | null
  file_size_bytes?: number | null
  sha256?: string | null
  updater_download_source?: DesktopReleaseSource | null
  updater_oss_object_key?: string | null
  updater_custom_download_url?: string | null
  updater_download_url?: string | null
  updater_file_name?: string | null
  updater_file_size_bytes?: number | null
  updater_sha256?: string | null
  release_notes?: string | null
  force_update: boolean
  enabled: boolean
  published_at?: string | null
  created_at: string
  updated_at: string
}

export interface DesktopClientReleasePayload {
  platform: DesktopReleasePlatform
  arch: DesktopReleaseArch
  channel: string
  version: string
  min_supported_version?: string | null
  download_source: DesktopReleaseSource
  oss_object_key?: string | null
  custom_download_url?: string | null
  file_name?: string | null
  file_size_bytes?: number | null
  sha256?: string | null
  updater_download_source?: DesktopReleaseSource | null
  updater_oss_object_key?: string | null
  updater_custom_download_url?: string | null
  updater_file_name?: string | null
  updater_file_size_bytes?: number | null
  updater_sha256?: string | null
  release_notes?: string | null
  force_update: boolean
  enabled: boolean
}

export interface DesktopClientReleaseList {
  items: DesktopClientRelease[]
  total: number
  page: number
  size: number
}

export interface DesktopClientReleaseUploadResult {
  oss_object_key: string
  file_name: string
  file_size_bytes: number
  sha256: string
}

export interface DesktopClientReleaseDownloadURLResult {
  download_url: string
  expires_in?: number | null
}

const DESKTOP_CLIENT_RELEASE_UPLOAD_TIMEOUT_MS = 30 * 60 * 1000
const DESKTOP_CLIENT_RELEASE_CHUNK_TIMEOUT_MS = 5 * 60 * 1000
const DESKTOP_CLIENT_RELEASE_CHUNK_SIZE_BYTES = 16 * 1024 * 1024
const DESKTOP_CLIENT_RELEASE_CHUNK_RETRIES = 2

export interface DesktopClientReleaseUploadProgress {
  loaded: number
  total?: number
  percent?: number
  stage?: 'uploading' | 'complete'
  chunkIndex?: number
  chunkCount?: number
}

interface DesktopClientReleaseUploadSession {
  upload_id: string
  chunk_size_bytes: number
  chunk_count: number
  uploaded_chunks: number[]
  expires_at: string
}

export const platformOptions = [
  { label: 'macOS', value: 'darwin' },
  { label: 'Windows', value: 'win32' },
  { label: 'Linux', value: 'linux' },
]

export const archOptions = [
  { label: 'Universal', value: 'universal' },
  { label: 'x64', value: 'x64' },
  { label: 'arm64', value: 'arm64' },
  { label: 'ia32', value: 'ia32' },
]

export const desktopClientReleaseApi = {
  list(params: {
    keyword?: string
    platform?: string
    channel?: string
    enabled?: string
    page?: number
    size?: number
  }) {
    return http.get<DesktopClientReleaseList>('/desktop-client/releases', params)
  },
  create(payload: DesktopClientReleasePayload) {
    return http.post<DesktopClientRelease, DesktopClientReleasePayload>(
      '/desktop-client/releases',
      payload,
    )
  },
  update(id: number, payload: DesktopClientReleasePayload) {
    return http.patch<DesktopClientRelease, DesktopClientReleasePayload>(
      `/desktop-client/releases/${id}`,
      payload,
    )
  },
  setEnabled(id: number, enabled: boolean) {
    return http.post<DesktopClientRelease, { enabled: boolean }>(
      `/desktop-client/releases/${id}/enabled`,
      { enabled },
    )
  },
  async uploadOSS(
    file: File,
    target: {
      platform: string
      arch: string
      channel: string
      version: string
      kind?: 'installer' | 'updater'
      onProgress?: (progress: DesktopClientReleaseUploadProgress) => void
    },
  ) {
    return uploadOSSInChunks(file, target)
  },
  async uploadOSSLegacy(
    file: File,
    target: {
      platform: string
      arch: string
      channel: string
      version: string
      kind?: 'installer' | 'updater'
      onProgress?: (progress: DesktopClientReleaseUploadProgress) => void
    },
  ) {
    const form = new FormData()
    form.append('file', file, file.name)
    form.append('platform', target.platform)
    form.append('arch', target.arch)
    form.append('channel', target.channel)
    form.append('version', target.version)
    form.append('kind', target.kind ?? 'installer')
    const response = await http.raw.post<{
      code: number
      message: string
      data: DesktopClientReleaseUploadResult
    }>('/desktop-client/releases/upload', form, {
      timeout: DESKTOP_CLIENT_RELEASE_UPLOAD_TIMEOUT_MS,
      onUploadProgress(event) {
        const total = event.total
        target.onProgress?.({
          loaded: event.loaded,
          total,
          percent: total ? Math.min(100, Math.round((event.loaded / total) * 100)) : undefined,
          stage: 'uploading',
        })
      },
    })
    return response.data.data
  },
  resolveDownloadURL(id: number) {
    return http.get<DesktopClientReleaseDownloadURLResult>(
      `/desktop-client/releases/${id}/download-url`,
    )
  },
  delete(id: number) {
    return http.delete<{ id: number }>(`/desktop-client/releases/${id}`)
  },
}

async function uploadOSSInChunks(
  file: File,
  target: {
    platform: string
    arch: string
    channel: string
    version: string
    kind?: 'installer' | 'updater'
    onProgress?: (progress: DesktopClientReleaseUploadProgress) => void
  },
): Promise<DesktopClientReleaseUploadResult> {
  const session = await http.post<DesktopClientReleaseUploadSession>(
    '/desktop-client/release-uploads',
    {
      platform: target.platform,
      arch: target.arch,
      channel: target.channel,
      version: target.version,
      kind: target.kind ?? 'installer',
      file_name: file.name,
      file_size_bytes: file.size,
      chunk_size_bytes: DESKTOP_CLIENT_RELEASE_CHUNK_SIZE_BYTES,
    },
  )

  const chunkSize = session.chunk_size_bytes || DESKTOP_CLIENT_RELEASE_CHUNK_SIZE_BYTES
  const chunkCount = session.chunk_count || Math.ceil(file.size / chunkSize)
  const uploaded = new Set(session.uploaded_chunks ?? [])
  let confirmedBytes = 0
  for (const index of uploaded) {
    confirmedBytes += chunkByteSize(file.size, chunkSize, index, chunkCount)
  }
  emitChunkProgress(target, confirmedBytes, file.size, chunkCount)

  try {
    for (let index = 0; index < chunkCount; index += 1) {
      if (uploaded.has(index)) continue
      await uploadChunkWithRetry(
        file,
        session.upload_id,
        index,
        chunkSize,
        chunkCount,
        confirmedBytes,
        target,
      )
      confirmedBytes += chunkByteSize(file.size, chunkSize, index, chunkCount)
      emitChunkProgress(target, confirmedBytes, file.size, chunkCount, index)
    }

    target.onProgress?.({
      loaded: file.size,
      total: file.size,
      percent: 100,
      stage: 'complete',
      chunkCount,
    })
    return await http.post<DesktopClientReleaseUploadResult>(
      `/desktop-client/release-uploads/${session.upload_id}/complete`,
    )
  } catch (error) {
    void http.delete(`/desktop-client/release-uploads/${session.upload_id}`).catch(() => undefined)
    throw error
  }
}

async function uploadChunkWithRetry(
  file: File,
  uploadID: string,
  index: number,
  chunkSize: number,
  chunkCount: number,
  confirmedBytes: number,
  target: {
    onProgress?: (progress: DesktopClientReleaseUploadProgress) => void
  },
) {
  let lastError: unknown
  for (let attempt = 0; attempt <= DESKTOP_CLIENT_RELEASE_CHUNK_RETRIES; attempt += 1) {
    try {
      await uploadChunk(file, uploadID, index, chunkSize, chunkCount, confirmedBytes, target)
      return
    } catch (error) {
      lastError = error
      if (attempt === DESKTOP_CLIENT_RELEASE_CHUNK_RETRIES) break
      await delay(400 * (attempt + 1))
    }
  }
  throw lastError
}

async function uploadChunk(
  file: File,
  uploadID: string,
  index: number,
  chunkSize: number,
  chunkCount: number,
  confirmedBytes: number,
  target: {
    onProgress?: (progress: DesktopClientReleaseUploadProgress) => void
  },
) {
  const start = index * chunkSize
  const end = Math.min(start + chunkSize, file.size)
  const chunk = file.slice(start, end)
  const form = new FormData()
  form.append('file', chunk, file.name)
  await http.raw.post(`/desktop-client/release-uploads/${uploadID}/chunks/${index}`, form, {
    timeout: DESKTOP_CLIENT_RELEASE_CHUNK_TIMEOUT_MS,
    onUploadProgress(event) {
      const loaded = confirmedBytes + Math.min(event.loaded, chunk.size)
      target.onProgress?.({
        loaded,
        total: file.size,
        percent: file.size ? Math.min(99, Math.round((loaded / file.size) * 100)) : undefined,
        stage: 'uploading',
        chunkIndex: index,
        chunkCount,
      })
    },
  })
}

function emitChunkProgress(
  target: { onProgress?: (progress: DesktopClientReleaseUploadProgress) => void },
  loaded: number,
  total: number,
  chunkCount: number,
  chunkIndex?: number,
) {
  target.onProgress?.({
    loaded,
    total,
    percent: total ? Math.min(99, Math.round((loaded / total) * 100)) : undefined,
    stage: 'uploading',
    chunkIndex,
    chunkCount,
  })
}

function chunkByteSize(fileSize: number, chunkSize: number, index: number, chunkCount: number) {
  if (index < 0 || index >= chunkCount) return 0
  const start = index * chunkSize
  return Math.max(0, Math.min(chunkSize, fileSize - start))
}

function delay(ms: number) {
  return new Promise((resolve) => window.setTimeout(resolve, ms))
}

export function platformLabel(value: string): string {
  return platformOptions.find((item) => item.value === value)?.label ?? value
}