furumi-ng/furumi-node-player/client/src/furumiApi.ts

import axios from 'axios'
import type { Album, Artist, SearchResult, Track, TrackDetail } from './types'

const FURUMI_API_BASE = import.meta.env.VITE_FURUMI_API_URL ?? ''
export const API_ROOT = `${FURUMI_API_BASE}/api`

export const furumiApi = axios.create({
  baseURL: API_ROOT,
})

export function setAuthToken(token: string) {
  furumiApi.defaults.headers.common['Authorization'] = `Bearer ${token}`
}

export function clearAuthToken() {
  delete furumiApi.defaults.headers.common['Authorization']
}

async function refreshToken(): Promise<boolean> {
  try {
    const res = await fetch('/auth/token', { credentials: 'include' })
    if (!res.ok) return false
    const data = await res.json()
    if (data.access_token) {
      setAuthToken(data.access_token)
      return true
    }
  } catch { /* ignore */ }
  return false
}

let refreshPromise: Promise<boolean> | null = null

furumiApi.interceptors.response.use(
  (response) => response,
  async (error) => {
    const original = error.config
    if (error.response?.status === 401 && !original._retried) {
      original._retried = true
      // Deduplicate concurrent refresh attempts
      if (!refreshPromise) {
        refreshPromise = refreshToken().finally(() => { refreshPromise = null })
      }
      const ok = await refreshPromise
      if (ok) return furumiApi(original)
    }
    return Promise.reject(error)
  },
)

export async function getArtists(): Promise<Artist[] | null> {
  const res = await furumiApi.get<Artist[]>('/artists').catch(() => null)
  return res?.data ?? null
}

export async function getArtistAlbums(artistSlug: string): Promise<Album[] | null> {
  const res = await furumiApi.get<Album[]>(`/artists/${artistSlug}/albums`).catch(() => null)
  return res?.data ?? null
}

export async function getAlbumTracks(albumSlug: string): Promise<Track[] | null> {
  const res = await furumiApi.get<Track[]>(`/albums/${albumSlug}`).catch(() => null)
  return res?.data ?? null
}

export async function getArtistTracks(artistSlug: string): Promise<Track[] | null> {
  const res = await furumiApi.get<Track[]>(`/artists/${artistSlug}/tracks`).catch(() => null)
  return res?.data ?? null
}

export async function searchTracks(query: string): Promise<SearchResult[] | null> {
  const res = await furumiApi
    .get<SearchResult[]>(`/search?q=${encodeURIComponent(query)}`)
    .catch(() => null)
  return res?.data ?? null
}

export async function getTrackInfo(trackSlug: string): Promise<TrackDetail | null> {
  const res = await furumiApi.get<TrackDetail>(`/tracks/${trackSlug}`).catch(() => null)
  return res?.data ?? null
}

export type RecentPlay = {
  track_slug: string
  track_title: string
  artist_name: string
  album_slug: string | null
  played_at: string
}

export async function getRecentPlays(): Promise<RecentPlay[] | null> {
  const res = await furumiApi.get<RecentPlay[]>('/me/recent').catch(() => null)
  return res?.data ?? null
}

export async function recordPlay(trackSlug: string): Promise<void> {
  await furumiApi.post(`/tracks/${trackSlug}/play`).catch(() => null)
}

export async function preloadStream(trackSlug: string) {
  return await furumiApi.get(`/stream/${trackSlug}`, { responseType: 'blob' }).catch(() => null)
}

export async function fetchCoverBlob(trackSlug: string): Promise<string | null> {
  const res = await furumiApi.get(`/tracks/${trackSlug}/cover`, { responseType: 'blob' }).catch(() => null)
  if (!res?.data) return null
  return URL.createObjectURL(res.data)
}