geo/apps/desktop-client/src/main/adapters/media-image.ts

import { Buffer } from 'node:buffer'

import { nativeImage } from 'electron'

import { fetchDesktopApiURL, resolveDesktopApiURL } from '../transport/api-client'
import { adapterFetch, mergeAbortSignals, timeoutSignal, type AdapterFetchOptions } from './common'

export interface ImageAssetBlob {
  blob: Blob
  width: number
  height: number
  fileName: string
}

export interface CropRect {
  x: number
  y: number
  width: number
  height: number
}

const passthroughImageTypes = new Set(['image/png', 'image/jpeg', 'image/jpg', 'image/gif'])

function buildDesktopAssetFallbackURL(publicAssetUrl: URL): string | null {
  if (!publicAssetUrl.pathname.startsWith('/api/public/assets/')) {
    return null
  }

  const token = publicAssetUrl.pathname.slice('/api/public/assets/'.length)
  if (!token) {
    return null
  }

  const fallbackURL = new URL(resolveDesktopApiURL(`/api/desktop/content/assets/${token}`))
  publicAssetUrl.searchParams.forEach((value, key) => {
    fallbackURL.searchParams.set(key, value)
  })
  fallbackURL.searchParams.set('format', 'png')
  return fallbackURL.toString()
}

export function buildAssetURLCandidates(sourceUrl: string): string[] {
  const trimmed = sourceUrl.trim()
  if (!trimmed) {
    return []
  }

  if (/^(data|blob):/i.test(trimmed)) {
    return [trimmed]
  }

  const candidates: string[] = []
  const pushCandidate = (value: string) => {
    if (!candidates.includes(value)) {
      candidates.push(value)
    }
  }

  try {
    const parsed = new URL(trimmed, resolveDesktopApiURL('/'))

    if (parsed.pathname.startsWith('/api/')) {
      const apiAssetUrl = new URL(resolveDesktopApiURL(`${parsed.pathname}${parsed.search}`))
      if (apiAssetUrl.pathname.startsWith('/api/public/assets/')) {
        apiAssetUrl.searchParams.set('format', 'png')
      }
      pushCandidate(apiAssetUrl.toString())

      const desktopAssetFallbackURL = buildDesktopAssetFallbackURL(apiAssetUrl)
      if (desktopAssetFallbackURL) {
        pushCandidate(desktopAssetFallbackURL)
      }
    }

    pushCandidate(parsed.toString())
  } catch {
    pushCandidate(trimmed)
  }

  return candidates
}

function shouldUseDesktopAssetFetch(candidate: string): boolean {
  try {
    return new URL(candidate).pathname.startsWith('/api/desktop/content/assets/')
  } catch {
    return false
  }
}

function fileNameForImageType(sourceType: string): string {
  if (sourceType === 'image/gif') {
    return 'image.gif'
  }
  if (sourceType === 'image/jpeg' || sourceType === 'image/jpg') {
    return 'image.jpg'
  }
  return 'image.png'
}

export async function fetchImageAssetBlob(
  sourceUrl: string,
  options: AdapterFetchOptions = {},
): Promise<ImageAssetBlob | null> {
  for (const candidate of buildAssetURLCandidates(sourceUrl)) {
    const response = await (
      shouldUseDesktopAssetFetch(candidate)
        ? fetchDesktopApiURL(candidate, {
            signal: mergeAbortSignals([options.signal, timeoutSignal(options.timeoutMs ?? 10_000)]),
          })
        : adapterFetch(
            candidate,
            {},
            { timeoutMs: options.timeoutMs ?? 10_000, signal: options.signal },
          )
    ).catch(() => null)
    if (!response?.ok) {
      continue
    }

    const sourceBlob = await response.blob().catch(() => null)
    if (!sourceBlob || !sourceBlob.type.startsWith('image/')) {
      continue
    }

    const image = nativeImage.createFromBuffer(Buffer.from(await sourceBlob.arrayBuffer()))
    if (image.isEmpty()) {
      continue
    }

    const size = image.getSize()
    const sourceType = sourceBlob.type.toLowerCase()
    if (passthroughImageTypes.has(sourceType)) {
      return {
        blob: sourceBlob,
        width: size.width,
        height: size.height,
        fileName: fileNameForImageType(sourceType),
      }
    }

    return {
      blob: new Blob([new Uint8Array(image.toPNG())], { type: 'image/png' }),
      width: size.width,
      height: size.height,
      fileName: 'image.png',
    }
  }

  return null
}

export function getCenteredCropRect(width: number, height: number, ratio: number): CropRect {
  let cropWidth = width
  let cropHeight = cropWidth / ratio
  if (cropHeight > height) {
    cropHeight = height
    cropWidth = cropHeight * ratio
  }

  return {
    x: (width - cropWidth) / 2,
    y: (height - cropHeight) / 2,
    width: cropWidth,
    height: cropHeight,
  }
}

export async function cropImageAssetBlob(
  source: ImageAssetBlob,
  ratio: number,
): Promise<ImageAssetBlob | null> {
  const image = nativeImage.createFromBuffer(Buffer.from(await source.blob.arrayBuffer()))
  if (image.isEmpty()) {
    return null
  }

  const crop = getCenteredCropRect(source.width, source.height, ratio)
  const cropped = image.crop({
    x: Math.max(0, Math.round(crop.x)),
    y: Math.max(0, Math.round(crop.y)),
    width: Math.max(1, Math.round(crop.width)),
    height: Math.max(1, Math.round(crop.height)),
  })
  if (cropped.isEmpty()) {
    return null
  }

  const size = cropped.getSize()
  return {
    blob: new Blob([new Uint8Array(cropped.toPNG())], { type: 'image/png' }),
    width: size.width,
    height: size.height,
    fileName: 'image.png',
  }
}