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

from server.client import services
from server.constants.distributors import DISTRIBUTORS
from server.constants.playlists.delphi.by_api.track_positions_playlists import TrackPositionsPlaylists
from server.scenarios.playlists.tracks.core import check_delphi_include, process_track_in_playlists_items
from server.utils.common import unpack_enum_list
from server.utils.mappers.core.getters import getter


async def get_track_playlists_extended(
    dsp: DSP,
    isrc: Optional[str] = None,
    playlist_id: Optional[str] = None,
    country_code: Optional[List[str]] = None,
    streams_country_code: Optional[List[TrackPositionsPlaylists.STREAMS_COUNTRY_CODE]] = None,
    playlist_name_contains: Optional[str] = None,
    playlist_owner_category_id: Optional[int] = None,
    start_date: Optional[date] = None,
    end_date: Optional[date] = None,
    min_added_date: Optional[date] = None,
    delphi_include: Optional[List[TrackPositionsPlaylists.INCLUDE]] = None,
    sort_by: Optional[List[TrackPositionsPlaylists.SORT_BY]] = None,
    sort_order: Optional[List[TrackPositionsPlaylists.SORT_ORDER]] = None,
    expand_isrc_by_track_positions: bool = False,
    is_sony_country_code: Optional[str] = None,  # 'is_sony' is overridden by passing 'distributors' parameters
    include_is_sony: bool = False,
    include_audio_features: bool = False,
    apple_country_code: Optional[str] = None,
    distributors_country_code: Optional[str] = None,
    distributors: Optional[List[DISTRIBUTORS]] = None,
) -> Dict[str, List[Dict[str, Any]]]:
    """Get playlists by track
    USE AT LEAST ONE OF [isrc, playlist_id] params

        Args:
            dsp: Playlist DSP filter.
            isrc: ISRC.
            playlist_id: Playlist ID.
            country_code: Playlist country code filter.
            streams_country_code: Streams country code list.
            playlist_name_contains: Search
            playlist_owner_category_id: Category
            start_date: The earliest date to include in the query range. Data is start_date inclusive.
            end_date: The latest date to include in the query. Data returned is end_date inclusive
            min_added_date:
            delphi_include: Delphi include
            is_sony_country_code: Country code for is Sony check.
            sort_by: Delphi sort by
            sort_order: Delphi sort order
            expand_isrc_by_track_positions:
            include_is_sony:
            include_audio_features:
            apple_country_code: Apple country code.
                Apple has one playlist ID for all markets,
                so it is necessary to specify this country code to get playlist for specific country.
            distributors_country_code: Country code for distributors check (same as for is_sony_country_code)
            distributors: Distributors list - passing non empty value overrides is_sony_country_code and include_is_sony,
            they will be ignored.

    Returns:
        Playlists tracks.
    """

    delphi_include = check_delphi_include(delphi_include, include_is_sony)

    result = await services.dsp.get_public_track_positions_playlists(
        dsp=dsp.value,
        isrc=isrc,
        playlist_id=playlist_id,
        start_date=start_date,
        end_date=end_date,
        country_code=country_code,
        streams_country_code=unpack_enum_list(streams_country_code, allow_str=True),
        min_added_date=min_added_date,
        playlist_owner_category_id=playlist_owner_category_id,
        sort_by=unpack_enum_list(sort_by),
        sort_order=unpack_enum_list(sort_order),
        include=unpack_enum_list(delphi_include),
        playlist_name_contains=playlist_name_contains,
        expand_isrc_by_track_positions=expand_isrc_by_track_positions,
        apple_country_code=apple_country_code,
    )

    await process_track_in_playlists_items(
        items=result["items"],
        dsp=dsp,
        is_sony_country_code=is_sony_country_code,
        include_is_sony=include_is_sony,
        include_audio_features=include_audio_features,
        with_playlists=TrackPositionsPlaylists.INCLUDE.PLAYLISTS in delphi_include if delphi_include else False,
        with_tracks=TrackPositionsPlaylists.INCLUDE.TRACK_INFO in delphi_include if delphi_include else False,
        distributors=distributors,
        distributors_country_code=distributors_country_code,
    )

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

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