getPlaylist method

Implementation

Future<JsonMap> getPlaylist(
  String playlistId, {
  int? limit = 100,
  bool related = false,
  int suggestionsLimit = 0,
}) async {
  checkAuth();
  final browseId = playlistId.startsWith('VL') ? playlistId : 'VL$playlistId';
  final body = {'browseId': browseId};
  const endpoint = 'browse';
  Future<JsonMap> requestFunc(String additionalParams) =>
      sendRequest(endpoint, body, additionalParams: additionalParams);

  final response = await requestFunc('');

  Future<JsonMap> requestFuncContinuations(JsonMap body) =>
      sendRequest(endpoint, body);

  if (playlistId.startsWith('OLA') || playlistId.startsWith('VLOLA')) {
    return parseAudioPlaylist(response, limit, requestFuncContinuations);
  }

  final headerData =
      nav(response, [
            ...TWO_COLUMN_RENDERER,
            ...TAB_CONTENT,
            ...SECTION_LIST_ITEM,
          ])
          as JsonMap;
  final sectionList =
      nav(response, [...TWO_COLUMN_RENDERER, 'secondaryContents', ...SECTION])
          as JsonMap;

  final playlist = <String, dynamic>{};
  playlist['owned'] = headerData.containsKey(
    EDITABLE_PLAYLIST_DETAIL_HEADER[0],
  );

  late JsonMap header;

  if (!(playlist['owned'] as bool)) {
    header = nav(headerData, RESPONSIVE_HEADER) as JsonMap;
    playlist['id'] = nav(header, [
      'buttons',
      1,
      'musicPlayButtonRenderer',
      'playNavigationEndpoint',
      ...WATCH_PLAYLIST_ID,
    ], nullIfAbsent: true);
    playlist['privacy'] = 'PUBLIC';
  } else {
    playlist['id'] = nav(headerData, [
      ...EDITABLE_PLAYLIST_DETAIL_HEADER,
      ...PLAYLIST_ID,
    ]);
    header =
        nav(headerData, [
              ...EDITABLE_PLAYLIST_DETAIL_HEADER,
              ...HEADER,
              ...RESPONSIVE_HEADER,
            ])
            as JsonMap;
    playlist['privacy'] =
        (((headerData[EDITABLE_PLAYLIST_DETAIL_HEADER[0]]
                    as JsonMap)['editHeader']
                as JsonMap)['musicPlaylistEditHeaderRenderer']
            as JsonMap)['privacy'];
  }

  final descriptionShelf =
      nav(header, ['description', ...DESCRIPTION_SHELF], nullIfAbsent: true)
          as JsonMap?;
  playlist['description'] =
      descriptionShelf != null
          ? ((descriptionShelf['description'] as JsonMap)['runs']
                  as List<JsonMap>)
              .map((run) => run['text'])
              .join()
          : null;

  playlist.addAll(parsePlaylistHeaderMeta(header));

  playlist.addAll(
    parseSongRuns(
      (nav(header, SUBTITLE_RUNS) as List).sublist(
        2 + ((playlist['owned'] as bool) ? 2 : 0),
      ),
    ),
  );

  // suggestions and related are missing e.g. on liked songs
  playlist['related'] = [];

  if (sectionList.containsKey('continuations')) {
    var additionalParams = getContinuationParams(sectionList);
    if ((playlist['owned'] as bool) && (suggestionsLimit > 0 || related)) {
      List parseFunc(results) => parsePlaylistItems(results as List<JsonMap>);
      final suggested = await requestFunc(additionalParams);
      final continuation = nav(suggested, SECTION_LIST_CONTINUATION);
      additionalParams = getContinuationParams(continuation as JsonMap);
      final suggestionsShelf = nav(continuation, [
        ...CONTENT,
        ...MUSIC_SHELF,
      ]);
      playlist['suggestions'] = getContinuationContents(
        suggestionsShelf as JsonMap,
        parseFunc,
      );
      (playlist['suggestions'] as List).addAll(
        await getReloadableContinuations(
          suggestionsShelf,
          'musicShelfContinuation',
          suggestionsLimit -
              ((playlist['suggestions'] as List).length), // TODO
          requestFunc,
          parseFunc,
        ),
      );
    }

    if (related) {
      final relatedResponse = await requestFunc(additionalParams);
      final continuation = nav(
        relatedResponse,
        SECTION_LIST_CONTINUATION,
        nullIfAbsent: true,
      );
      if (continuation != null) {
        Future<List> parseFunc(results) =>
            parseContentList(results as List<JsonMap>, parsePlaylist);
        playlist['related'] = getContinuationContents(
          nav(continuation, [...CONTENT, ...CAROUSEL]) as JsonMap,
          parseFunc,
        );
      }
    }
  }

  playlist['tracks'] = [];
  final contentData =
      nav(sectionList, [...CONTENT, 'musicPlaylistShelfRenderer']) as JsonMap;
  if (contentData.containsKey('contents')) {
    playlist['tracks'] = parsePlaylistItems(
      contentData['contents'] as List<JsonMap>,
    );
    List parseFunc(contents) => parsePlaylistItems(contents as List<JsonMap>);
    (playlist['tracks'] as List).addAll(
      await getContinuations2025(
        contentData,
        limit,
        requestFuncContinuations,
        parseFunc,
      ),
    );
  }

  playlist['duration_seconds'] = sumTotalDuration(playlist);

  return playlist;
}