from aiohttp import web
from aiohttp_apispec import docs, querystring_schema

from server.constants import BASE_API_PREFIX, DSP, cache_keys
from server.constants.market import Market
from server.constants.playlists.delphi.by_api.track_positions_playlists import TrackPositionsPlaylists
from server.constants.playlists.meta import PlaylistMetaApolloInclude
from server.scenarios.playlists.by_track.extended.common import get_track_playlists_extended
from server.scenarios.playlists.get_playlist_meta.common import get_meta_playlists_info
from server.scenarios.playlists.tracks.common import get_playlist_tracklist, get_playlist_tracklist_v_3_1_v_3_2
from server.schemas.playlists.spotify.tracks import V1PlaylistsSpotifyAnalyze, V1PlaylistsSpotifyTracklist, \
    V1PlaylistsSpotifyTracks, V1PlaylistsSpotifyTracksHistory
from server.utils.pagination import paginate
from server.utils.response import dump_response_schema


router = web.RouteTableDef()


@router.get(BASE_API_PREFIX + "/v1/playlists/spotify/tracks/")
@docs(
    tags=["playlists", "spotify", "tracks"],
    summary="Get current Spotify playlist's tracks.",
)
@querystring_schema(V1PlaylistsSpotifyTracks.Request)
@dump_response_schema(V1PlaylistsSpotifyTracks.Response, apply=False)
async def get(request: web.Request) -> web.Response:
    params = request["querystring"]
    playlist_id, country_code = params["playlist_id"], params["country_code"]
    country_code_def = country_code or "local"

    result = await get_playlist_tracklist(
        dsp=DSP.SPOTIFY,
        playlist_id=playlist_id,
        streams_country_code_list=[country_code_def, Market.WORLDWIDE],
        include_list=[TrackPositionsPlaylists.INCLUDE.TRACK_INFO, TrackPositionsPlaylists.INCLUDE.STREAMS_FOR_PERIOD],
        include_audio_features=True,
        include_playlist=True,
        distributors=params.get("distributors", []),
        distributors_country_code=country_code,
    )

    return V1PlaylistsSpotifyTracks.Response(context={"country_code": country_code_def}).dump({"tracks": result})


@router.get(BASE_API_PREFIX + "/v1/playlists/spotify/tracks/history/")
@docs(
    tags=["playlists", "spotify", "tracks"],
    summary="Get Spotify playlist's tracks for chosen date.",
)
@querystring_schema(V1PlaylistsSpotifyTracksHistory.Request)
@dump_response_schema(V1PlaylistsSpotifyTracksHistory.Response, apply=False)
async def get(request: web.Request) -> web.Response:
    params = request["querystring"]
    playlist_id, tracklist_date, country_code = params["playlist_id"], params["date"], params["country_code"]
    country_code_def = country_code or TrackPositionsPlaylists.STREAMS_COUNTRY_CODE.LOCAL.value

    result = await get_track_playlists_extended(
        dsp=DSP.SPOTIFY,
        playlist_id=playlist_id,
        streams_country_code=[country_code_def, Market.WORLDWIDE],
        start_date=tracklist_date,
        end_date=tracklist_date,
        delphi_include=[
            TrackPositionsPlaylists.INCLUDE.PLAYLISTS,
            TrackPositionsPlaylists.INCLUDE.TRACK_INFO,
            TrackPositionsPlaylists.INCLUDE.STREAMS_FOR_PERIOD,
        ],
        expand_isrc_by_track_positions=True,
        include_audio_features=True,
        distributors=params.get("distributors", []),
        distributors_country_code=country_code,
    )

    return V1PlaylistsSpotifyTracksHistory.Response(context={"country_code": country_code_def}).dump(
        {"items": result["items"]}
    )


@router.get(BASE_API_PREFIX + "/v1/playlists/spotify/tracklist/")
@docs(
    tags=["playlists", "tracks", "spotify"],
    summary="Get Track data in Spotify playlist identified by passed isrc and playlist_id.",
)
@querystring_schema(V1PlaylistsSpotifyTracklist.Request)
@dump_response_schema(V1PlaylistsSpotifyTracklist.Response, apply=False)
@paginate(cache_keys.V1_SPOTIFY_PLAYLIST_TRACKLIST)
async def get(request: web.Request) -> web.Response:
    params = request["querystring"]
    return await get_playlist_tracklist_v_3_1_v_3_2(
        dsp=DSP.SPOTIFY,
        schema=V1PlaylistsSpotifyTracklist.Response.TrackItem,
        cache_key=cache_keys.V1_SPOTIFY_PLAYLIST_TRACKLIST,
        **params,
    )


@router.get(BASE_API_PREFIX + "/v1/playlists/spotify/analyze/")
@docs(
    tags=["playlists", "tracks", "spotify"],
    summary="Test url to get analyze data",
)
@querystring_schema(V1PlaylistsSpotifyAnalyze.Request)
@dump_response_schema(V1PlaylistsSpotifyAnalyze.Response)
async def get(request: web.Request) -> web.Response:
    params = request["querystring"]
    playlist_id = params.get("playlist_id") or params.get("playlisturi")
    meta = await get_meta_playlists_info(
        playlist_list_id=[playlist_id],
        dsp=DSP.SPOTIFY,
        apollo_include=[PlaylistMetaApolloInclude.PLAYLIST_DATES_FULL.value],
    )
    return meta[0] if meta else {}