import { beforeEach, describe, expect, it, vi } from 'vitest';
import {
  createMultiCollection,
  deleteMultiCollection,
  getMultiCollection,
  getMultiCollections,
  messageFromMultiCollectionError,
  updateMultiCollection
} from './multiCollections';
import { ApiError } from './client';

function jsonResponse(body: unknown, status = 200): Response {
  return new Response(JSON.stringify(body), {
    headers: { 'Content-Type': 'application/json' },
    status
  });
}

function noContent(): Response {
  return new Response(null, { status: 204 });
}

describe('multiCollections api client', () => {
  beforeEach(() => {
    window.localStorage.clear();
    vi.restoreAllMocks();
  });

  it('getMultiCollections maps paging params into the query string', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ page: [], totalCount: 0 }));

    await getMultiCollections({ pageNum: 2, pageSize: 25, query: 'kids' });

    const url = new URL(String(fetchMock.mock.calls[0][0]), 'http://localhost');
    expect(url.pathname).toBe('/api/v1/multi-collections');
    expect(url.searchParams.get('pageNum')).toBe('2');
    expect(url.searchParams.get('pageSize')).toBe('25');
    expect(url.searchParams.get('query')).toBe('kids');
  });

  it('getMultiCollections with no params hits the bare endpoint', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ page: [], totalCount: 0 }));

    await getMultiCollections();

    expect(fetchMock).toHaveBeenCalledWith('/api/v1/multi-collections', expect.objectContaining({ method: 'GET' }));
  });

  it('getMultiCollection fetches a single multi-collection by id', async () => {
    const fetchMock = vi
      .spyOn(window, 'fetch')
      .mockResolvedValue(jsonResponse({ id: 4, items: [], name: 'Bundle' }));

    await expect(getMultiCollection(4)).resolves.toMatchObject({ id: 4 });
    expect(fetchMock).toHaveBeenCalledWith('/api/v1/multi-collections/4', expect.objectContaining({ method: 'GET' }));
  });

  it('createMultiCollection POSTs the name and items', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ id: 9, items: [], name: 'New' }, 201));

    const body = {
      items: [{ collectionId: 3, playbackOrder: 'Chronological' as const, scheduleAsGroup: true, smartCollectionId: null }],
      name: 'New'
    };
    await expect(createMultiCollection(body)).resolves.toMatchObject({ id: 9 });

    const [url, init] = fetchMock.mock.calls[0];
    expect(url).toBe('/api/v1/multi-collections');
    expect(init).toMatchObject({ method: 'POST' });
    expect(JSON.parse(String(init?.body))).toEqual(body);
  });

  it('updateMultiCollection PUTs to the id route', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ id: 5, items: [], name: 'Renamed' }));

    const body = {
      items: [{ collectionId: null, playbackOrder: 'Chronological' as const, scheduleAsGroup: false, smartCollectionId: 7 }],
      name: 'Renamed'
    };
    await updateMultiCollection(5, body);

    const [url, init] = fetchMock.mock.calls[0];
    expect(url).toBe('/api/v1/multi-collections/5');
    expect(init).toMatchObject({ method: 'PUT' });
    expect(JSON.parse(String(init?.body))).toEqual(body);
  });

  it('deleteMultiCollection issues a DELETE and resolves on 204', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(noContent());

    await expect(deleteMultiCollection(6)).resolves.toBeUndefined();
    expect(fetchMock).toHaveBeenCalledWith('/api/v1/multi-collections/6', expect.objectContaining({ method: 'DELETE' }));
  });

  it('messageFromMultiCollectionError narrows ApiError, Error, and unknown', () => {
    expect(messageFromMultiCollectionError(new ApiError(422, { detail: 'In use', title: 'Unprocessable' }))).toBe('In use');
    expect(messageFromMultiCollectionError(new Error('boom'))).toBe('boom');
    expect(messageFromMultiCollectionError('nope', 'fallback')).toBe('fallback');
  });
});