feishin/src/renderer/api/jellyfin/jellyfin-controller.ts

import {
    AuthenticationResponse,
    MusicFolderListArgs,
    MusicFolderListResponse,
    GenreListArgs,
    AlbumArtistDetailArgs,
    AlbumArtistListArgs,
    albumArtistListSortMap,
    sortOrderMap,
    ArtistListArgs,
    artistListSortMap,
    AlbumDetailArgs,
    AlbumListArgs,
    albumListSortMap,
    TopSongListArgs,
    SongListArgs,
    songListSortMap,
    AddToPlaylistArgs,
    RemoveFromPlaylistArgs,
    PlaylistDetailArgs,
    PlaylistSongListArgs,
    PlaylistListArgs,
    playlistListSortMap,
    CreatePlaylistArgs,
    CreatePlaylistResponse,
    UpdatePlaylistArgs,
    UpdatePlaylistResponse,
    DeletePlaylistArgs,
    FavoriteArgs,
    FavoriteResponse,
    ScrobbleArgs,
    ScrobbleResponse,
    GenreListResponse,
    AlbumArtistDetailResponse,
    AlbumArtistListResponse,
    AlbumDetailResponse,
    AlbumListResponse,
    SongListResponse,
    AddToPlaylistResponse,
    RemoveFromPlaylistResponse,
    PlaylistDetailResponse,
    PlaylistListResponse,
    SearchArgs,
    SearchResponse,
    RandomSongListResponse,
    RandomSongListArgs,
    LyricsArgs,
    LyricsResponse,
    genreListSortMap,
    SongDetailArgs,
    SongDetailResponse,
    ServerInfo,
    ServerInfoArgs,
    SimilarSongsArgs,
    Song,
    MoveItemArgs,
} from '/@/renderer/api/types';
import { jfApiClient } from '/@/renderer/api/jellyfin/jellyfin-api';
import { jfNormalize } from './jellyfin-normalize';
import { jfType } from '/@/renderer/api/jellyfin/jellyfin-types';
import { z } from 'zod';
import { JFSongListSort, JFSortOrder } from '/@/renderer/api/jellyfin.types';
import { ServerFeature } from '/@/renderer/api/features-types';
import { VersionInfo, getFeatures } from '/@/renderer/api/utils';
import chunk from 'lodash/chunk';

const formatCommaDelimitedString = (value: string[]) => {
    return value.join(',');
};

const authenticate = async (
    url: string,
    body: {
        password: string;
        username: string;
    },
): Promise<AuthenticationResponse> => {
    const cleanServerUrl = url.replace(/\/$/, '');

    const res = await jfApiClient({ server: null, url: cleanServerUrl }).authenticate({
        body: {
            Pw: body.password,
            Username: body.username,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to authenticate');
    }

    return {
        credential: res.body.AccessToken,
        userId: res.body.User.Id,
        username: res.body.User.Name,
    };
};

const getMusicFolderList = async (args: MusicFolderListArgs): Promise<MusicFolderListResponse> => {
    const { apiClientProps } = args;
    const userId = apiClientProps.server?.userId;

    if (!userId) throw new Error('No userId found');

    const res = await jfApiClient(apiClientProps).getMusicFolderList({
        params: {
            userId,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get genre list');
    }

    const musicFolders = res.body.Items.filter(
        (folder) => folder.CollectionType === jfType._enum.collection.MUSIC,
    );

    return {
        items: musicFolders.map(jfNormalize.musicFolder),
        startIndex: 0,
        totalRecordCount: musicFolders?.length || 0,
    };
};

const getGenreList = async (args: GenreListArgs): Promise<GenreListResponse> => {
    const { apiClientProps, query } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getGenreList({
        query: {
            Fields: 'ItemCounts',
            ParentId: query?.musicFolderId,
            Recursive: true,
            SearchTerm: query?.searchTerm,
            SortBy: genreListSortMap.jellyfin[query.sortBy] || 'SortName',
            SortOrder: sortOrderMap.jellyfin[query.sortOrder],
            StartIndex: query.startIndex,
            UserId: apiClientProps.server?.userId,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get genre list');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.genre(item, apiClientProps.server)),
        startIndex: query.startIndex || 0,
        totalRecordCount: res.body?.TotalRecordCount || 0,
    };
};

const getAlbumArtistDetail = async (
    args: AlbumArtistDetailArgs,
): Promise<AlbumArtistDetailResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getAlbumArtistDetail({
        params: {
            id: query.id,
            userId: apiClientProps.server?.userId,
        },
        query: {
            Fields: 'Genres, Overview',
        },
    });

    const similarArtistsRes = await jfApiClient(apiClientProps).getSimilarArtistList({
        params: {
            id: query.id,
        },
        query: {
            Limit: 10,
        },
    });

    if (res.status !== 200 || similarArtistsRes.status !== 200) {
        throw new Error('Failed to get album artist detail');
    }

    return jfNormalize.albumArtist(
        { ...res.body, similarArtists: similarArtistsRes.body },
        apiClientProps.server,
    );
};

const getAlbumArtistList = async (args: AlbumArtistListArgs): Promise<AlbumArtistListResponse> => {
    const { query, apiClientProps } = args;

    const res = await jfApiClient(apiClientProps).getAlbumArtistList({
        query: {
            Fields: 'Genres, DateCreated, ExternalUrls, Overview',
            ImageTypeLimit: 1,
            Limit: query.limit,
            ParentId: query.musicFolderId,
            Recursive: true,
            SearchTerm: query.searchTerm,
            SortBy: albumArtistListSortMap.jellyfin[query.sortBy] || 'SortName,Name',
            SortOrder: sortOrderMap.jellyfin[query.sortOrder],
            StartIndex: query.startIndex,
            UserId: apiClientProps.server?.userId || undefined,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get album artist list');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.albumArtist(item, apiClientProps.server)),
        startIndex: query.startIndex,
        totalRecordCount: res.body.TotalRecordCount,
    };
};

const getArtistList = async (args: ArtistListArgs): Promise<AlbumArtistListResponse> => {
    const { query, apiClientProps } = args;

    const res = await jfApiClient(apiClientProps).getAlbumArtistList({
        query: {
            Limit: query.limit,
            ParentId: query.musicFolderId,
            Recursive: true,
            SortBy: artistListSortMap.jellyfin[query.sortBy] || 'SortName,Name',
            SortOrder: sortOrderMap.jellyfin[query.sortOrder],
            StartIndex: query.startIndex,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get artist list');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.albumArtist(item, apiClientProps.server)),
        startIndex: query.startIndex,
        totalRecordCount: res.body.TotalRecordCount,
    };
};

const getAlbumDetail = async (args: AlbumDetailArgs): Promise<AlbumDetailResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getAlbumDetail({
        params: {
            id: query.id,
            userId: apiClientProps.server.userId,
        },
        query: {
            Fields: 'Genres, DateCreated, ChildCount',
        },
    });

    const songsRes = await jfApiClient(apiClientProps).getSongList({
        params: {
            userId: apiClientProps.server.userId,
        },
        query: {
            Fields: 'Genres, DateCreated, MediaSources, ParentId',
            IncludeItemTypes: 'Audio',
            ParentId: query.id,
            SortBy: 'ParentIndexNumber,IndexNumber,SortName',
        },
    });

    if (res.status !== 200 || songsRes.status !== 200) {
        throw new Error('Failed to get album detail');
    }

    return jfNormalize.album({ ...res.body, Songs: songsRes.body.Items }, apiClientProps.server);
};

const getAlbumList = async (args: AlbumListArgs): Promise<AlbumListResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const yearsGroup = [];
    if (query._custom?.jellyfin?.minYear && query._custom?.jellyfin?.maxYear) {
        for (
            let i = Number(query._custom?.jellyfin?.minYear);
            i <= Number(query._custom?.jellyfin?.maxYear);
            i += 1
        ) {
            yearsGroup.push(String(i));
        }
    }

    const yearsFilter = yearsGroup.length ? yearsGroup.join(',') : undefined;

    const res = await jfApiClient(apiClientProps).getAlbumList({
        params: {
            userId: apiClientProps.server?.userId,
        },
        query: {
            AlbumArtistIds: query.artistIds
                ? formatCommaDelimitedString(query.artistIds)
                : undefined,
            IncludeItemTypes: 'MusicAlbum',
            Limit: query.limit,
            ParentId: query.musicFolderId,
            Recursive: true,
            SearchTerm: query.searchTerm,
            SortBy: albumListSortMap.jellyfin[query.sortBy] || 'SortName',
            SortOrder: sortOrderMap.jellyfin[query.sortOrder],
            StartIndex: query.startIndex,
            ...query._custom?.jellyfin,
            Years: yearsFilter,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get album list');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.album(item, apiClientProps.server)),
        startIndex: query.startIndex,
        totalRecordCount: res.body.TotalRecordCount,
    };
};

const getTopSongList = async (args: TopSongListArgs): Promise<SongListResponse> => {
    const { apiClientProps, query } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getTopSongsList({
        params: {
            userId: apiClientProps.server?.userId,
        },
        query: {
            ArtistIds: query.artistId,
            Fields: 'Genres, DateCreated, MediaSources, ParentId',
            IncludeItemTypes: 'Audio',
            Limit: query.limit,
            Recursive: true,
            SortBy: 'PlayCount,SortName',
            SortOrder: 'Descending',
            UserId: apiClientProps.server?.userId,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get top song list');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
        startIndex: 0,
        totalRecordCount: res.body.TotalRecordCount,
    };
};

const getSongList = async (args: SongListArgs): Promise<SongListResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const yearsGroup = [];
    if (query._custom?.jellyfin?.minYear && query._custom?.jellyfin?.maxYear) {
        for (
            let i = Number(query._custom?.jellyfin?.minYear);
            i <= Number(query._custom?.jellyfin?.maxYear);
            i += 1
        ) {
            yearsGroup.push(String(i));
        }
    }

    const yearsFilter = yearsGroup.length ? formatCommaDelimitedString(yearsGroup) : undefined;
    const albumIdsFilter = query.albumIds ? formatCommaDelimitedString(query.albumIds) : undefined;
    const artistIdsFilter = query.artistIds
        ? formatCommaDelimitedString(query.artistIds)
        : undefined;

    const res = await jfApiClient(apiClientProps).getSongList({
        params: {
            userId: apiClientProps.server?.userId,
        },
        query: {
            AlbumIds: albumIdsFilter,
            ArtistIds: artistIdsFilter,
            Fields: 'Genres, DateCreated, MediaSources, ParentId',
            IncludeItemTypes: 'Audio',
            Limit: query.limit,
            ParentId: query.musicFolderId,
            Recursive: true,
            SearchTerm: query.searchTerm,
            SortBy: songListSortMap.jellyfin[query.sortBy] || 'Album,SortName',
            SortOrder: sortOrderMap.jellyfin[query.sortOrder],
            StartIndex: query.startIndex,
            ...query._custom?.jellyfin,
            Years: yearsFilter,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get song list');
    }

    let items: z.infer<typeof jfType._response.song>[];

    // Jellyfin Bodge because of code from https://github.com/jellyfin/jellyfin/blob/c566ccb63bf61f9c36743ddb2108a57c65a2519b/Emby.Server.Implementations/Data/SqliteItemRepository.cs#L3622
    // If the Album ID filter is passed, Jellyfin will search for
    //  1. the matching album id
    //  2. An album with the name of the album.
    // It is this second condition causing issues,
    if (query.albumIds) {
        const albumIdSet = new Set(query.albumIds);
        items = res.body.Items.filter((item) => albumIdSet.has(item.AlbumId));

        if (items.length < res.body.Items.length) {
            res.body.TotalRecordCount -= res.body.Items.length - items.length;
        }
    } else {
        items = res.body.Items;
    }

    return {
        items: items.map((item) =>
            jfNormalize.song(item, apiClientProps.server, '', query.imageSize),
        ),
        startIndex: query.startIndex,
        totalRecordCount: res.body.TotalRecordCount,
    };
};

// Limit the query to 50 at a time to be *extremely* conservative on the
// length of the full URL, since the ids are part of the query string and
// not the POST body
const MAX_ITEMS_PER_PLAYLIST_ADD = 50;

const addToPlaylist = async (args: AddToPlaylistArgs): Promise<AddToPlaylistResponse> => {
    const { query, body, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const chunks = chunk(body.songId, MAX_ITEMS_PER_PLAYLIST_ADD);

    for (const chunk of chunks) {
        const res = await jfApiClient(apiClientProps).addToPlaylist({
            body: null,
            params: {
                id: query.id,
            },
            query: {
                Ids: chunk.join(','),
                UserId: apiClientProps.server?.userId,
            },
        });

        if (res.status !== 204) {
            throw new Error('Failed to add to playlist');
        }
    }

    return null;
};

const removeFromPlaylist = async (
    args: RemoveFromPlaylistArgs,
): Promise<RemoveFromPlaylistResponse> => {
    const { query, apiClientProps } = args;

    const chunks = chunk(query.songId, MAX_ITEMS_PER_PLAYLIST_ADD);

    for (const chunk of chunks) {
        const res = await jfApiClient(apiClientProps).removeFromPlaylist({
            body: null,
            params: {
                id: query.id,
            },
            query: {
                EntryIds: chunk.join(','),
            },
        });

        if (res.status !== 204) {
            throw new Error('Failed to remove from playlist');
        }
    }

    return null;
};

const getPlaylistDetail = async (args: PlaylistDetailArgs): Promise<PlaylistDetailResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getPlaylistDetail({
        params: {
            id: query.id,
            userId: apiClientProps.server?.userId,
        },
        query: {
            Fields: 'Genres, DateCreated, MediaSources, ChildCount, ParentId',
            Ids: query.id,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get playlist detail');
    }

    return jfNormalize.playlist(res.body, apiClientProps.server);
};

const getPlaylistSongList = async (args: PlaylistSongListArgs): Promise<SongListResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getPlaylistSongList({
        params: {
            id: query.id,
        },
        query: {
            Fields: 'Genres, DateCreated, MediaSources, UserData, ParentId',
            IncludeItemTypes: 'Audio',
            Limit: query.limit,
            SortBy: query.sortBy ? songListSortMap.jellyfin[query.sortBy] : undefined,
            SortOrder: query.sortOrder ? sortOrderMap.jellyfin[query.sortOrder] : undefined,
            StartIndex: query.startIndex,
            UserId: apiClientProps.server?.userId,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get playlist song list');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
        startIndex: query.startIndex,
        totalRecordCount: res.body.TotalRecordCount,
    };
};

const getPlaylistList = async (args: PlaylistListArgs): Promise<PlaylistListResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getPlaylistList({
        params: {
            userId: apiClientProps.server?.userId,
        },
        query: {
            Fields: 'ChildCount, Genres, DateCreated, ParentId, Overview',
            IncludeItemTypes: 'Playlist',
            Limit: query.limit,
            MediaTypes: 'Audio',
            Recursive: true,
            SearchTerm: query.searchTerm,
            SortBy: playlistListSortMap.jellyfin[query.sortBy],
            SortOrder: sortOrderMap.jellyfin[query.sortOrder],
            StartIndex: query.startIndex,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get playlist list');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.playlist(item, apiClientProps.server)),
        startIndex: 0,
        totalRecordCount: res.body.TotalRecordCount,
    };
};

const createPlaylist = async (args: CreatePlaylistArgs): Promise<CreatePlaylistResponse> => {
    const { body, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).createPlaylist({
        body: {
            MediaType: 'Audio',
            Name: body.name,
            Overview: body.comment || '',
            UserId: apiClientProps.server.userId,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to create playlist');
    }

    return {
        id: res.body.Id,
    };
};

const updatePlaylist = async (args: UpdatePlaylistArgs): Promise<UpdatePlaylistResponse> => {
    const { query, body, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).updatePlaylist({
        body: {
            Genres: body.genres?.map((item) => ({ Id: item.id, Name: item.name })) || [],
            MediaType: 'Audio',
            Name: body.name,
            Overview: body.comment || '',
            PremiereDate: null,
            ProviderIds: {},
            Tags: [],
            UserId: apiClientProps.server?.userId, // Required
        },
        params: {
            id: query.id,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to update playlist');
    }

    return null;
};

const deletePlaylist = async (args: DeletePlaylistArgs): Promise<null> => {
    const { query, apiClientProps } = args;

    const res = await jfApiClient(apiClientProps).deletePlaylist({
        body: null,
        params: {
            id: query.id,
        },
    });

    if (res.status !== 204) {
        throw new Error('Failed to delete playlist');
    }

    return null;
};

const createFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    for (const id of query.id) {
        await jfApiClient(apiClientProps).createFavorite({
            body: {},
            params: {
                id,
                userId: apiClientProps.server?.userId,
            },
        });
    }

    return null;
};

const deleteFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    for (const id of query.id) {
        await jfApiClient(apiClientProps).removeFavorite({
            body: {},
            params: {
                id,
                userId: apiClientProps.server?.userId,
            },
        });
    }

    return null;
};

const scrobble = async (args: ScrobbleArgs): Promise<ScrobbleResponse> => {
    const { query, apiClientProps } = args;

    const position = query.position && Math.round(query.position);

    if (query.submission) {
        // Checked by jellyfin-plugin-lastfm for whether or not to send the "finished" scrobble (uses PositionTicks)
        jfApiClient(apiClientProps).scrobbleStopped({
            body: {
                IsPaused: true,
                ItemId: query.id,
                PositionTicks: position,
            },
        });

        return null;
    }

    if (query.event === 'start') {
        jfApiClient(apiClientProps).scrobblePlaying({
            body: {
                ItemId: query.id,
                PositionTicks: position,
            },
        });

        return null;
    }

    if (query.event === 'pause') {
        jfApiClient(apiClientProps).scrobbleProgress({
            body: {
                EventName: query.event,
                IsPaused: true,
                ItemId: query.id,
                PositionTicks: position,
            },
        });

        return null;
    }

    if (query.event === 'unpause') {
        jfApiClient(apiClientProps).scrobbleProgress({
            body: {
                EventName: query.event,
                IsPaused: false,
                ItemId: query.id,
                PositionTicks: position,
            },
        });

        return null;
    }

    jfApiClient(apiClientProps).scrobbleProgress({
        body: {
            ItemId: query.id,
            PositionTicks: position,
        },
    });

    return null;
};

const search = async (args: SearchArgs): Promise<SearchResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    let albums: z.infer<typeof jfType._response.albumList>['Items'] = [];
    let albumArtists: z.infer<typeof jfType._response.albumArtistList>['Items'] = [];
    let songs: z.infer<typeof jfType._response.songList>['Items'] = [];

    if (query.albumLimit) {
        const res = await jfApiClient(apiClientProps).getAlbumList({
            params: {
                userId: apiClientProps.server?.userId,
            },
            query: {
                EnableTotalRecordCount: true,
                ImageTypeLimit: 1,
                IncludeItemTypes: 'MusicAlbum',
                Limit: query.albumLimit,
                Recursive: true,
                SearchTerm: query.query,
                SortBy: 'SortName',
                SortOrder: 'Ascending',
                StartIndex: query.albumStartIndex || 0,
            },
        });

        if (res.status !== 200) {
            throw new Error('Failed to get album list');
        }

        albums = res.body.Items;
    }

    if (query.albumArtistLimit) {
        const res = await jfApiClient(apiClientProps).getAlbumArtistList({
            query: {
                EnableTotalRecordCount: true,
                Fields: 'Genres, DateCreated, ExternalUrls, Overview',
                ImageTypeLimit: 1,
                IncludeArtists: true,
                Limit: query.albumArtistLimit,
                Recursive: true,
                SearchTerm: query.query,
                StartIndex: query.albumArtistStartIndex || 0,
                UserId: apiClientProps.server?.userId,
            },
        });

        if (res.status !== 200) {
            throw new Error('Failed to get album artist list');
        }

        albumArtists = res.body.Items;
    }

    if (query.songLimit) {
        const res = await jfApiClient(apiClientProps).getSongList({
            params: {
                userId: apiClientProps.server?.userId,
            },
            query: {
                EnableTotalRecordCount: true,
                Fields: 'Genres, DateCreated, MediaSources, ParentId',
                IncludeItemTypes: 'Audio',
                Limit: query.songLimit,
                Recursive: true,
                SearchTerm: query.query,
                SortBy: 'Album,SortName',
                SortOrder: 'Ascending',
                StartIndex: query.songStartIndex || 0,
                UserId: apiClientProps.server?.userId,
            },
        });

        if (res.status !== 200) {
            throw new Error('Failed to get song list');
        }

        songs = res.body.Items;
    }

    return {
        albumArtists: albumArtists.map((item) =>
            jfNormalize.albumArtist(item, apiClientProps.server),
        ),
        albums: albums.map((item) => jfNormalize.album(item, apiClientProps.server)),
        songs: songs.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
    };
};

const getRandomSongList = async (args: RandomSongListArgs): Promise<RandomSongListResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const yearsGroup = [];
    if (query.minYear && query.maxYear) {
        for (let i = Number(query.minYear); i <= Number(query.maxYear); i += 1) {
            yearsGroup.push(String(i));
        }
    }

    const yearsFilter = yearsGroup.length ? formatCommaDelimitedString(yearsGroup) : undefined;

    const res = await jfApiClient(apiClientProps).getSongList({
        params: {
            userId: apiClientProps.server?.userId,
        },
        query: {
            Fields: 'Genres, DateCreated, MediaSources, ParentId',
            GenreIds: query.genre ? query.genre : undefined,
            IncludeItemTypes: 'Audio',
            Limit: query.limit,
            ParentId: query.musicFolderId,
            Recursive: true,
            SortBy: JFSongListSort.RANDOM,
            SortOrder: JFSortOrder.ASC,
            StartIndex: 0,
            Years: yearsFilter,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get random songs');
    }

    return {
        items: res.body.Items.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
        startIndex: 0,
        totalRecordCount: res.body.Items.length || 0,
    };
};

const getLyrics = async (args: LyricsArgs): Promise<LyricsResponse> => {
    const { query, apiClientProps } = args;

    if (!apiClientProps.server?.userId) {
        throw new Error('No userId found');
    }

    const res = await jfApiClient(apiClientProps).getSongLyrics({
        params: {
            id: query.songId,
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get lyrics');
    }

    if (res.body.Lyrics.length > 0 && res.body.Lyrics[0].Start === undefined) {
        return res.body.Lyrics.map((lyric) => lyric.Text).join('\n');
    }

    return res.body.Lyrics.map((lyric) => [lyric.Start! / 1e4, lyric.Text]);
};

const getSongDetail = async (args: SongDetailArgs): Promise<SongDetailResponse> => {
    const { query, apiClientProps } = args;

    const res = await jfApiClient(apiClientProps).getSongDetail({
        params: {
            id: query.id,
            userId: apiClientProps.server?.userId ?? '',
        },
    });

    if (res.status !== 200) {
        throw new Error('Failed to get song detail');
    }

    return jfNormalize.song(res.body, apiClientProps.server, '');
};

const VERSION_INFO: VersionInfo = [['10.9.0', { [ServerFeature.LYRICS_SINGLE_STRUCTURED]: [1] }]];

const getServerInfo = async (args: ServerInfoArgs): Promise<ServerInfo> => {
    const { apiClientProps } = args;

    const res = await jfApiClient(apiClientProps).getServerInfo();

    if (res.status !== 200) {
        throw new Error('Failed to get server info');
    }

    const features = getFeatures(VERSION_INFO, res.body.Version);

    return {
        features,
        id: apiClientProps.server?.id,
        version: res.body.Version,
    };
};

const getSimilarSongs = async (args: SimilarSongsArgs): Promise<Song[]> => {
    const { apiClientProps, query } = args;

    // Prefer getSimilarSongs, where possible. Fallback to InstantMix
    // where no similar songs were found.
    const res = await jfApiClient(apiClientProps).getSimilarSongs({
        params: {
            itemId: query.songId,
        },
        query: {
            Fields: 'Genres, DateCreated, MediaSources, ParentId',
            Limit: query.count,
            UserId: apiClientProps.server?.userId || undefined,
        },
    });

    if (res.status === 200 && res.body.Items.length) {
        const results = res.body.Items.reduce<Song[]>((acc, song) => {
            if (song.Id !== query.songId) {
                acc.push(jfNormalize.song(song, apiClientProps.server, ''));
            }

            return acc;
        }, []);

        if (results.length > 0) {
            return results;
        }
    }

    const mix = await jfApiClient(apiClientProps).getInstantMix({
        params: {
            itemId: query.songId,
        },
        query: {
            Fields: 'Genres, DateCreated, MediaSources, ParentId',
            Limit: query.count,
            UserId: apiClientProps.server?.userId || undefined,
        },
    });

    if (mix.status !== 200) {
        throw new Error('Failed to get similar songs');
    }

    return mix.body.Items.reduce<Song[]>((acc, song) => {
        if (song.Id !== query.songId) {
            acc.push(jfNormalize.song(song, apiClientProps.server, ''));
        }

        return acc;
    }, []);
};

const movePlaylistItem = async (args: MoveItemArgs): Promise<void> => {
    const { apiClientProps, query } = args;

    const res = await jfApiClient(apiClientProps).movePlaylistItem({
        body: null,
        params: {
            itemId: query.trackId,
            newIdx: query.endingIndex.toString(),
            playlistId: query.playlistId,
        },
    });

    if (res.status !== 204) {
        throw new Error('Failed to move item in playlist');
    }
};

export const jfController = {
    addToPlaylist,
    authenticate,
    createFavorite,
    createPlaylist,
    deleteFavorite,
    deletePlaylist,
    getAlbumArtistDetail,
    getAlbumArtistList,
    getAlbumDetail,
    getAlbumList,
    getArtistList,
    getGenreList,
    getLyrics,
    getMusicFolderList,
    getPlaylistDetail,
    getPlaylistList,
    getPlaylistSongList,
    getRandomSongList,
    getServerInfo,
    getSimilarSongs,
    getSongDetail,
    getSongList,
    getTopSongList,
    movePlaylistItem,
    removeFromPlaylist,
    scrobble,
    search,
    updatePlaylist,
};