getPlaylist method

Implementation

Future<JsonMap> getPlaylist(
  String playlistId, {
  int? limit = 100,
  bool related = false,
  int suggestionsLimit = 0,
}) async {
  // checkAuth(); // TODO this was in original code, can be removed?
  final browseId = playlistId.startsWith('VL') ? playlistId : 'VL$playlistId';
  final JsonMap 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);

  final isOla =
      playlistId.startsWith('OLA') || playlistId.startsWith('VLOLA');
  final hasPlaylistHeader =
      nav(response, [
        ...TWO_COLUMN_RENDERER,
        ...TAB_CONTENT,
        ...SECTION_LIST_ITEM,
      ], nullIfAbsent: true) !=
      null;
  if (isOla && !hasPlaylistHeader) {
    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
          ? List<JsonMap>.from(
            (descriptionShelf['description'] as JsonMap)['runs'] as List,
          ).map((run) => run['text']).join()
          : null;

  playlist.addAll(parsePlaylistHeaderMeta(header));
  final isCollaborative = playlist.containsKey('collaborators');

  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(List<JsonMap>.from(results as List));
      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(
          List<JsonMap>.from(results as List),
          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(
      List<JsonMap>.from(contentData['contents'] as List),
      isCollaborative: isCollaborative,
    );
    List parseFunc(contents) => parsePlaylistItems(
      List<JsonMap>.from(contents as List),
      isCollaborative: isCollaborative,
    );
    (playlist['tracks'] as List).addAll(
      List<JsonMap>.from(
        await getContinuations2025(
          contentData,
          limit,
          requestFuncContinuations,
          parseFunc,
        ),
      ),
    );
  }

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

  return playlist;
}