import asyncio
import itertools
from aiohttp import web
from aiohttp_apispec import docs, querystring_schema, response_schema
from datetime import timedelta

from server.constants.delphi.streams.group_by import StreamsGroupBy
from server.constants.delphi.streams.include import StreamsInclude
from server.legacy.analytics import utils as analytics_utils
from server.legacy.analytics import view_utils
from server.legacy.consumer_analytics import deserializers, util
from server.legacy.consumer_analytics import view_utils as ca_view_utils
from server.legacy.core import constants
from server.legacy.core.constants import APPLE


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get single track streams per playlist.",
)
@querystring_schema(deserializers.TrackPlaylistSummaryDeserializer)
async def tracks_playlists_summary_view(request: web.Request) -> web.Response:
    api = request.app["delphi_java_api"]
    data = request["querystring"]
    end_date = await analytics_utils.get_last_date_value(api=api, data=data, key="last_date")
    start_date = end_date - timedelta(days=6)
    market = data["market"]

    response = await util.get_tracks_playlists_summary(
        api, data["isrc"], data["vendor"], start_date, end_date, market, None, all_markets=False, add_isrc=False
    )
    result = util.get_track_playlists_streams(response, market)
    return web.json_response(result)


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get multiple track streams per playlist in V1 format.",
)
@querystring_schema(deserializers.TrackPlaylistSummaryV1Deserializer)
async def tracks_playlists_summary_v1_view(request: web.Request) -> web.Response:
    api = request.app["delphi_java_api"]
    data = request["querystring"]
    start_date, end_date = data["start_date"], data["end_date"]
    market, vendor = data["market"], data["vendor"]
    raw_all_markets = data.get("all_markets")
    all_markets = (vendor == APPLE) if raw_all_markets is None else raw_all_markets

    tasks = [
        util.get_tracks_playlists_summary(
            api, isrc, vendor, start_date, end_date, market, None, all_markets=all_markets, add_isrc=True
        )
        for isrc in data["isrc_list"]
    ]
    responses = await asyncio.gather(*tasks)
    res = list(itertools.chain(*[r["items"] for r in responses]))
    return web.json_response({"items": res})


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get multiple tracks streams count per date range.",
)
@querystring_schema(deserializers.TracksStreamsCountParams)
async def tracks_streams_view(request: web.Request) -> web.Response:
    return await view_utils.get_tracks_streams(request)


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get multiple tracks demographics data.",
)
@querystring_schema(deserializers.CATrackDemographicsViewParams)
async def ca_apple_track_demographics_view(request: web.Request) -> web.Response:
    api = request.app["delphi_java_api"]
    data = request["querystring"]

    response = await api.get_streams(
        isrc_list=data["isrc_list"],
        dsp_list=[constants.APPLE],
        start_date=data["start_date"],
        end_date=data["end_date"],
        group_by=[StreamsGroupBy.DATE],
        include=[StreamsInclude.DEMOGRAPHICS, StreamsInclude.SOURCES],
    )

    return web.json_response({"items": [util.get_apple_track_demographics_item(item) for item in response]})


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get single track streams in playlist for global and selected market per date.",
)
@querystring_schema(deserializers.CAAppleTrackInContainerViewParams)
async def ca_apple_track_in_container_view(request: web.Request) -> web.Response:
    return await ca_view_utils.get_track_playlist_summary_view(
        request, constants.APPLE, include_shuffle=False, per_day=True
    )


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get single track streams in playlist for global and selected market per date.",
)
@querystring_schema(deserializers.CASpotifyTrackInPlaylistV2ViewParams)
async def ca_spotify_track_in_playlist_v2_view(request: web.Request) -> web.Response:
    return await ca_view_utils.get_track_playlist_summary_view(
        request, constants.SPOTIFY, include_shuffle=False, per_day=True
    )


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get single track streams in playlist for global and selected market per date with summary.",
)
@querystring_schema(deserializers.CASpotifyTrackInPlaylistSummaryV2ViewParams)
async def ca_spotify_track_in_playlist_summary_v2_view(request: web.Request) -> web.Response:
    return await ca_view_utils.get_track_playlist_summary_view(
        request, constants.SPOTIFY, include_shuffle=False, per_day=True, include_summary=True
    )


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get single track streaming data.",
)
@querystring_schema(deserializers.TrackPerCountryViewParams)
async def tracks_per_country_view(request: web.Request) -> web.Response:
    return await ca_view_utils.get_tracks_per_country(request, exclude_global=False, include_owner_categories=False)


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get tracks streaming data v1.",
)
@querystring_schema(deserializers.TrackPerCountryV1.Request)
@response_schema(deserializers.TrackPerCountryV1.Response(many=True))
async def tracks_per_country_v1_view(request: web.Request) -> web.Response:
    api = request.app["delphi_java_api"]
    data = request["querystring"]
    combine_isrc = data["combine_isrc"]

    result = await util.get_streams_per_country_v1(
        api,
        data["isrc_list"],
        data["vendor"],
        data["start_date"],
        data["end_date"],
        data["market_list"],
        data["streams_only"],
        combine_isrc,
        data["exclude_global"],
    )

    if combine_isrc:
        result = result and result[0].get("data") or []
    return web.json_response(result)


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi data-health/completeness.",
    description="Get the latest stream dates available.",
)
@querystring_schema(deserializers.StreamsLatestDateViewParams)
async def streams_latest_date_view(request: web.Request) -> web.Response:
    api = request.app["delphi_java_api"]
    vendors = request["querystring"]["vendors"]

    dates = await api.get_latest_stream_dates()

    if len(vendors) == 1 and constants.ALL not in vendors:
        result = {"date": next(i["updated_date"] for i in dates if i["dsp"] in vendors)}
    else:
        result = {i["dsp"]: i["updated_date"] for i in dates if i["dsp"] in vendors or constants.ALL in vendors}
    return web.json_response(result)


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi stream-dates.",
    description="Get tracks first stream dates.",
)
@querystring_schema(deserializers.TracksFirstStreamDatesViewParams)
async def tracks_first_stream_dates_view(request: web.Request) -> web.Response:
    return await ca_view_utils.get_first_stream_dates(request)