from apollo_utils.core.constants.dsp import DSP
from datetime import date
from typing import List, Optional

from server.client import services
from server.constants.playlists.delphi.by_api.track_positions_previous_playlists import TrackPositionsPreviousPlaylists
from server.scenarios.playlists.tracks.core import process_track_in_playlists_items
from server.utils.common import unpack_enum_list
from server.utils.mappers.core.getters import getter


async def get_previous_playlists_by_track(
    dsp: DSP,
    isrc: str,
    country_code: Optional[List[str]] = None,
    playlist_name_contains: Optional[str] = None,
    playlist_owner_category_id: Optional[int] = None,
    min_removed_date: Optional[date] = None,
    delphi_include: Optional[List[TrackPositionsPreviousPlaylists.INCLUDE]] = None,
    sort_by: Optional[List[TrackPositionsPreviousPlaylists.SORT_BY]] = None,
    sort_order: Optional[List[TrackPositionsPreviousPlaylists.SORT_ORDER]] = None,
    with_categories: bool = False,
    streams_country_code: Optional[List[str]] = None,
):
    """Get previous playlists by track

    Args:
        dsp: Playlist DSP filter.
        isrc: ISRC.
        country_code: Playlist country code filter.
        playlist_name_contains: Search
        playlist_owner_category_id: Category
        min_removed_date:
        delphi_include: Delphi include
        sort_by: Delphi sort by
        sort_order: Delphi sort order
        with_categories: Include categories to response
        streams_country_code: Streams country code.

    Returns:
        Playlists tracks.
    """
    result = await services.dsp.get_public_track_positions_previous_playlists(
        dsp=dsp.value,
        isrc=isrc,
        country_code=country_code,
        include=unpack_enum_list(delphi_include),
        playlist_name_contains=playlist_name_contains,
        playlist_owner_category_id=playlist_owner_category_id,
        min_removed_date=min_removed_date,
        sort_by=unpack_enum_list(sort_by),
        sort_order=unpack_enum_list(sort_order),
        streams_country_code=streams_country_code,
    )

    await process_track_in_playlists_items(
        items=result["items"],
        dsp=dsp,
        with_playlists=TrackPositionsPreviousPlaylists.INCLUDE.PLAYLISTS in delphi_include if delphi_include else False,
    )

    categories = getter(item=result, key="meta.owner_categories", none_result=[]) if with_categories else []

    return {"items": result["items"], "categories": categories}