from aiohttp import web
from aiohttp_apispec import docs, querystring_schema

from server.client import services
from server.constants import BASE_API_PREFIX, DSP
from server.constants.charts.tracks.streams import ChartsTracksInclude
from server.constants.favorites import EntityType
from server.domains.charts.tracks.streams import parse_juno_response, update_juno_response
from server.scenarios.distributors import get_tracks_distributors_map
from server.scenarios.users.favorites import get_favorites_map
from server.schemas.charts.tracks.streams import ChartsTracks
from server.utils.common import no_prefix_str, prefix_str, to_dict
from server.utils.parallel import make_requests
from server.utils.response import dump_response_schema


router = web.RouteTableDef()


@router.get(BASE_API_PREFIX + "/charts/tracks/streams/spotify/")
@docs(tags=["juno", "tracks", "streams", "spotify"], summary="Get tracks by weekly Spotify streams (JUNO).")
@querystring_schema(ChartsTracks.Request)
@dump_response_schema(ChartsTracks.Response(many=True), apply=True)
async def get_charts_tracks_streams_spotify(request: web.Request) -> web.Response:
    params = request["querystring"]
    spotify_country_code, image_size, distributors, include_list = (
        params.pop("spotify_country_code"),
        params.pop("image_size"),
        params.pop("distributors", []),
        params.get("include", []),
    )
    include_spotify_meta, include_image_url, include_is_starred = (
        ChartsTracksInclude.SPOTIFY_META in include_list,
        ChartsTracksInclude.IMAGE_URL in include_list,
        ChartsTracksInclude.IS_STARRED in include_list,
    )
    params["include"] = (
        [ChartsTracksInclude.COUNTRY_CODES.value] if ChartsTracksInclude.COUNTRY_CODES in include_list else None
    )

    result = await services.dsp.get_juno_spotify_streams_latest(**params)

    track_id_list, episode_id_list, isrc_list = parse_juno_response(result)

    isrc_to_favorites_data, track_meta_list, episode_meta_list = await make_requests(
        (
            (
                get_favorites_map,
                dict(entity_id=isrc_list, entity_type=[EntityType.TRACK.value]),
                {},
                include_is_starred,
            ),
            (
                services.vendor.get_tracks,
                dict(dsp=DSP.SPOTIFY, ids=track_id_list, market=spotify_country_code),
                [],
                (include_image_url or include_spotify_meta) and track_id_list,
            ),
            (
                services.vendor.get_episodes,
                dict(ids=episode_id_list, market=spotify_country_code),
                [],
                (include_image_url or include_spotify_meta) and episode_id_list,
            ),
        )
    )

    track_to_distributor_mapping = {}
    if distributors and track_id_list:
        track_to_distributor_mapping = await get_tracks_distributors_map(
            country_code=spotify_country_code,
            track_id=track_id_list,
            dsp=DSP.SPOTIFY,
            distributors=distributors,
            track_list=track_meta_list,
            remove_result_dsp_prefix=True,
        )

    update_juno_response(
        data=result,
        is_starred_mapping=isrc_to_favorites_data,
        track_meta_mapping={i["uri"]: i for i in track_meta_list},
        episode_meta_mapping={i["uri"]: i for i in episode_meta_list},
        track_distributors_mapping=track_to_distributor_mapping,
        include_is_starred=include_is_starred,
        include_spotify_meta=include_spotify_meta,
        include_image_url=include_image_url,
        image_size=image_size,
    )

    return web.json_response(result)