api.ts

import { appState } from '../state/app'

export type ApiResult<T> = { data: T; error: null } | { data: null; error: string }

// JSON integers larger than Number.MAX_SAFE_INTEGER (2^53-1) lose precision when
// parsed as JS numbers. Convert any 16+ digit integer value to a string first.
const LARGE_INT_RE = /([:[,])\s*(-?\d{16,})(?=[,}\]\s])/g
function safeParseJson<T>(text: string): T {
  return JSON.parse(text.replace(LARGE_INT_RE, '$1 "$2"')) as T
}

function buildHeaders(includeJson: boolean): HeadersInit {
  const headers: Record<string, string> = {}
  const key = appState.apiKey.get()
  if (key) headers['X-API-KEY'] = key
  if (includeJson) headers['Content-Type'] = 'application/json'
  return headers
}

async function request<T>(path: string, init: RequestInit, skipBody = false): Promise<ApiResult<T>> {
  const url = appState.baseUrl.get() + path
  let response: Response
  try {
    response = await fetch(url, init)
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err)
    return { data: null, error: `Network error: ${msg}` }
  }
  if (!response.ok) {
    return { data: null, error: `HTTP ${response.status}: ${response.statusText}` }
  }
  if (skipBody) {
    return { data: null as T, error: null }
  }
  let data: T
  try {
    const text = await response.text()
    data = safeParseJson<T>(text)
  } catch {
    return { data: null, error: 'Invalid JSON response' }
  }
  return { data, error: null }
}

export async function get<T>(path: string): Promise<ApiResult<T>> {
  return request<T>(path, { method: 'GET', headers: buildHeaders(false) })
}

export async function post<T>(path: string, body?: unknown): Promise<ApiResult<T>> {
  return request<T>(path, {
    method: 'POST',
    headers: buildHeaders(true),
    body: JSON.stringify(body),
  })
}

export async function put<T>(path: string, body?: unknown): Promise<ApiResult<T>> {
  return request<T>(path, {
    method: 'PUT',
    headers: buildHeaders(true),
    body: JSON.stringify(body),
  })
}

export async function del(path: string): Promise<ApiResult<never>> {
  return request<never>(path, { method: 'DELETE', headers: buildHeaders(false) }, true)
}

export async function getEmpty(path: string): Promise<ApiResult<never>> {
  return request<never>(path, { method: 'GET', headers: buildHeaders(false) }, true)
}

export async function postForm<T>(path: string, formData: FormData): Promise<ApiResult<T>> {
  // No Content-Type header — browser sets multipart/form-data with boundary automatically
  return request<T>(path, {
    method: 'POST',
    headers: buildHeaders(false),
    body: formData,
  })
}

export async function postBinary<T>(path: string, data: ArrayBuffer | Blob): Promise<ApiResult<T>> {
  const url = appState.baseUrl.get() + path
  const headers = { ...(buildHeaders(false) as Record<string, string>), 'Content-Type': 'application/octet-stream' }
  let response: Response
  try {
    response = await fetch(url, { method: 'POST', headers, body: data })
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err)
    return { data: null, error: `Network error: ${msg}` }
  }
  if (!response.ok) return { data: null, error: `HTTP ${response.status}: ${response.statusText}` }
  let result: T
  try {
    result = safeParseJson<T>(await response.text())
  } catch {
    return { data: null, error: 'Invalid JSON response' }
  }
  return { data: result, error: null }
}

export async function getText(path: string): Promise<ApiResult<string>> {
  const url = appState.baseUrl.get() + path
  let response: Response
  try {
    response = await fetch(url, { method: 'GET', headers: buildHeaders(false) })
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err)
    return { data: null, error: `Network error: ${msg}` }
  }
  if (!response.ok) {
    return { data: null, error: `HTTP ${response.status}: ${response.statusText}` }
  }
  const text = await response.text()
  return { data: text, error: null }
}