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 UpdateCollectionCustomOrderRequest = components['schemas']['UpdateCollectionCustomOrderRequest'];
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. When the
// collection's useCustomPlaybackOrder is true, items come back ordered by CustomIndex (nulls
// last, then title); otherwise title order.
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()}`);
}

// Replaces a manual collection's custom order wholesale: the CustomIndex of each media item is
// derived from its position in `mediaItemIds`, so a partial array silently drops the items left
// out of it (#211). Callers must submit the full ordered id list.
export function updateCollectionCustomOrder(id: number, mediaItemIds: number[]): Promise<void> {
  const body: UpdateCollectionCustomOrderRequest = { mediaItemIds };
  return request<void>(`/api/collections/${id}/custom-order`, { body, method: 'PUT' });
}

/* ---------- 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. All 10 addable kinds (Movie /
// TelevisionShow / TelevisionSeason / Artist / Episode / MusicVideo / Song / OtherVideo /
// Image / RemoteStream) are reachable from the picker via `toAddItemsRequest` below — the
// default "All" fan-out only searches Movie/TelevisionShow/Artist (see CollectionsScreen's
// DEFAULT_SEARCH_KINDS), but every kind can be found by picking its specific filter.
export function emptyAddItemsRequest(): AddItemsToCollectionRequest {
  return {
    artistIds: [],
    episodeIds: [],
    imageIds: [],
    movieIds: [],
    musicVideoIds: [],
    otherVideoIds: [],
    remoteStreamIds: [],
    seasonIds: [],
    showIds: [],
    songIds: []
  };
}

// Buckets a set of browse results into an AddItemsToCollectionRequest. Each addable kind
// 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;
      case 'Episode':
        requestBody.episodeIds?.push(item.id);
        break;
      case 'MusicVideo':
        requestBody.musicVideoIds?.push(item.id);
        break;
      case 'Song':
        requestBody.songIds?.push(item.id);
        break;
      case 'OtherVideo':
        requestBody.otherVideoIds?.push(item.id);
        break;
      case 'Image':
        requestBody.imageIds?.push(item.id);
        break;
      case 'RemoteStream':
        requestBody.remoteStreamIds?.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;
}