ersatztv/web/src/api/collections.ts

import { ApiError, request } from './client';
import type { components } from './generated/v1';
import type { LibraryBrowseItem, PagedLibraryBrowseItems } from './libraryBrowse';

export type MediaCollection = components['schemas']['MediaCollectionViewModel'];
export type SmartCollection = components['schemas']['SmartCollectionViewModel'];
export type CreateCollectionRequest = components['schemas']['CreateCollectionRequest'];
export type UpdateCollectionRequest = components['schemas']['UpdateCollectionRequest'];
export type AddItemsToCollectionRequest = components['schemas']['AddItemsToCollectionRequest'];
export type CreateSmartCollectionRequest = components['schemas']['CreateSmartCollectionRequest'];
export type UpdateSmartCollectionRequest = components['schemas']['UpdateSmartCollectionRequest'];

/* ---------- manual collections ---------- */

export function getCollections(): Promise<MediaCollection[]> {
  return request<MediaCollection[]>('/api/collections');
}

export function getCollection(id: number): Promise<MediaCollection> {
  return request<MediaCollection>(`/api/collections/${id}`);
}

export function createCollection(body: CreateCollectionRequest): Promise<MediaCollection> {
  return request<MediaCollection>('/api/collections', { body, method: 'POST' });
}

export function updateCollection(id: number, body: UpdateCollectionRequest): Promise<MediaCollection> {
  return request<MediaCollection>(`/api/collections/${id}`, { body, method: 'PUT' });
}

export function deleteCollection(id: number): Promise<void> {
  return request<void>(`/api/collections/${id}`, { method: 'DELETE' });
}

export function addItemsToCollection(id: number, body: AddItemsToCollectionRequest): Promise<void> {
  return request<void>(`/api/collections/${id}/items`, { body, method: 'POST' });
}

export function removeItemFromCollection(id: number, mediaItemId: number): Promise<void> {
  return request<void>(`/api/collections/${id}/items/${mediaItemId}`, { method: 'DELETE' });
}

// Lists a manual collection's full contents (all media kinds), paged. Backed by
// GET /api/collections/{id}/items (#155), which reuses the library-browse item shape.
export function getCollectionItems(
  id: number,
  pageNum = 0,
  pageSize = 100
): Promise<PagedLibraryBrowseItems> {
  const params = new URLSearchParams({
    pageNum: String(pageNum),
    pageSize: String(pageSize)
  });
  return request<PagedLibraryBrowseItems>(`/api/collections/${id}/items?${params.toString()}`);
}

/* ---------- smart collections ---------- */

export function getSmartCollections(): Promise<SmartCollection[]> {
  return request<SmartCollection[]>('/api/smart-collections');
}

export function getSmartCollection(id: number): Promise<SmartCollection> {
  return request<SmartCollection>(`/api/smart-collections/${id}`);
}

export function createSmartCollection(body: CreateSmartCollectionRequest): Promise<SmartCollection> {
  return request<SmartCollection>('/api/smart-collections', { body, method: 'POST' });
}

export function updateSmartCollection(id: number, body: UpdateSmartCollectionRequest): Promise<SmartCollection> {
  return request<SmartCollection>(`/api/smart-collections/${id}`, { body, method: 'PUT' });
}

export function deleteSmartCollection(id: number): Promise<void> {
  return request<void>(`/api/smart-collections/${id}`, { method: 'DELETE' });
}

/* ---------- add-items bucket mapping ---------- */

// The add-items request buckets media-item ids by kind. The library-browse search only
// surfaces four kinds (Movie / TelevisionShow / TelevisionSeason / Artist), so those are
// the only buckets reachable from the picker. The remaining buckets (episodes, music
// videos, songs, images, other videos, remote streams) can't be produced by browse and
// are left empty here. See CollectionsScreen for the honest note about this limit.
export function emptyAddItemsRequest(): AddItemsToCollectionRequest {
  return {
    artistIds: [],
    episodeIds: [],
    imageIds: [],
    movieIds: [],
    musicVideoIds: [],
    otherVideoIds: [],
    remoteStreamIds: [],
    seasonIds: [],
    showIds: [],
    songIds: []
  };
}

// Buckets a set of browse results into an AddItemsToCollectionRequest. Movie / Show /
// Season / Artist are the only kinds library-browse can return as concrete media; each
// carries its media-item id in `id` (which equals `mediaItemId` for these types, since
// they are all MediaItem subclasses). Ids must go into their type-specific bucket, since
// the server validates each bucket against that entity type (a Show id in movieIds fails
// validation). Any other kind (collections, smart/multi/rerun collections, playlists) is
// not an addable media item and is skipped.
export function toAddItemsRequest(items: LibraryBrowseItem[]): AddItemsToCollectionRequest {
  const requestBody = emptyAddItemsRequest();

  for (const item of items) {
    switch (item.mediaType) {
      case 'Movie':
        requestBody.movieIds?.push(item.id);
        break;
      case 'TelevisionShow':
        requestBody.showIds?.push(item.id);
        break;
      case 'TelevisionSeason':
        requestBody.seasonIds?.push(item.id);
        break;
      case 'Artist':
        requestBody.artistIds?.push(item.id);
        break;
      default:
        break;
    }
  }

  return requestBody;
}

export function messageFromCollectionError(error: unknown, fallback = 'Unable to load collections'): string {
  if (error instanceof ApiError) {
    return error.detail ?? error.message;
  }

  if (error instanceof Error) {
    return error.message;
  }

  return fallback;
}