from aiohttp import web
from aiohttp_apispec import docs, json_schema, querystring_schema, response_schema

from server.legacy.analytics import deserializers as analytics_deserializers
from server.legacy.analytics import view_utils
from server.legacy.core import constants
from server.legacy.core.constants import APPLE, SPOTIFY
from server.legacy.delphi import deserializers
from server.legacy.delphi import view_utils as delphi_utils
from server.legacy.delphi.constants import YOUTUBE_URL_TEMPLATE
from server.legacy.delphi.schemas import DelphiChartPositionsDatesV3, DelphiTiktokTracksAnalyticsV3
from server.schemas.delphi.charts.analytics import DelphiChartsAnalytics
from server.schemas.delphi.charts.v3 import DelphiChartsV3
from server.schemas.delphi.deserializers.streams.dates import DelphiStreamDatesParams
from server.schemas.delphi.deserializers.streams.v3 import DelphiStreamsV3
from server.schemas.delphi.playlists import DelphiPlaylistsFollowers
from server.schemas.delphi.tracks.charts import DelphiTracksCharts
from server.schemas.delphi.videos.charts.positions import (
    DelphiVideoPositionsChartsSummaryV3,
    DelphiVideoPositionsChartsV3,
)


@docs(
    tags=["streams"],
    summary="Obsolete proxy endpoint for Delphi v3/streams.",
    description="Get amazon tracks streams data.",
)
@querystring_schema(deserializers.AmazonTracksStreamsV1Deserializer)
async def amazon_tracks_streams_v1_view(request: web.Request) -> web.Response:
    """Amazon streams for several tracks with combine_isrc option."""

    api = request.app["delphi_java_api"]
    data = request["querystring"]
    args = [data["isrc_list"], data["start_date"], data["end_date"], data.get("country_code"), data.get("group_by")]
    kwargs = {}
    combine_isrc, combine_tiers = data["combine_isrc"], data["combine_tiers"]

    if combine_isrc or combine_tiers:
        handler = delphi_utils.get_amazon_track_streams_v1
        kwargs.update(combine_isrc=combine_isrc, combine_tiers=combine_tiers)
    else:
        handler = delphi_utils.get_amazon_tracks_streams
        args.extend([data.get("offset"), data.get("limit")])

    result = await handler(api, *args, **kwargs)
    return web.json_response({"count": len(result), "items": result})


@json_schema(deserializers.TrackStreamDemographicsRequest)
@response_schema(deserializers.TrackStreamAppleDemographicItem(many=True))
async def apple_streams_demographic(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]

    data = request["json"]
    response = await delphi_java_api.get_streams_extended(
        isrc_items_list=data["items"],
        dsp=APPLE,
        country_code_list=data.get("market"),
        include=data["include"],
        combine_isrc=data["combine_isrc"],
    )
    return web.json_response(deserializers.TrackStreamAppleDemographicItem(many=True).dump(response))


@json_schema(deserializers.TrackStreamDemographicsRequest)
@response_schema(deserializers.TrackStreamSpotifyDemographicItem(many=True))
async def spotify_streams_demographic(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]

    data = request["json"]
    response = await delphi_java_api.get_streams_extended(
        isrc_items_list=data["items"],
        dsp=SPOTIFY,
        country_code_list=data.get("market"),
        include=data["include"],
        combine_isrc=data["combine_isrc"],
    )
    return web.json_response(deserializers.TrackStreamSpotifyDemographicItem(many=True).dump(response))


@querystring_schema(analytics_deserializers.TotalGlobalStreamsBulkDeserializer)
@response_schema(deserializers.TotalStreamsCountResponse)
async def total_streams_count_bulk_view(request: web.Request) -> web.Response:
    return await view_utils.get_total_streams_count(request, constants.ALL_VENDORS, first_stream_dates=True)


@docs(tags=["streams"], summary="Proxy endpoint for Delphi streams.", description="Get tracks streams data.")
@querystring_schema(DelphiStreamsV3.Request)
async def delphi_streams_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_streams(**data)
    return web.json_response(response)


@docs(tags=["streams"], summary="Proxy endpoint for Delphi stream-dates.", description="Get tracks first stream dates.")
@querystring_schema(DelphiStreamDatesParams)
async def delphi_first_stream_dates_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_first_stream_dates(**data)
    return web.json_response(response)


@docs(
    tags=["streams", "dates"],
    summary="Proxy endpoint for Delphi data-health/completeness.",
    description="Get the latest stream dates available.",
)
async def delphi_latest_stream_dates_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    response = await delphi_java_api.get_latest_stream_dates()
    return web.json_response(response)


@docs(
    tags=["streams", "videos"],
    summary="Proxy endpoint for Delphi video analytics.",
    description="Get videos streams and demographics data.",
)
@querystring_schema(deserializers.DelphiVideoAnalyticsInputParams)
async def delphi_video_analytics_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_video_analytics(**data)
    return web.json_response(response)


@docs(tags=["videos"], summary="Proxy endpoint for Delphi videos.", description="Get videos metadata.")
@querystring_schema(deserializers.DelphiVideosInputParams)
async def delphi_videos_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_videos(**data)
    return web.json_response(response)


@docs(tags=["videos"], summary="Proxy endpoint for Delphi videos/{video_id}.", description="Get single video metadata.")
async def delphi_video_details_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    video_id = request.match_info.get("video_id")
    response = await delphi_java_api.get_video(video_id)
    response["url"] = YOUTUBE_URL_TEMPLATE.format(video_id=response["dsp_video_id"])
    return web.json_response(response)


@docs(tags=["charts"], summary="Proxy endpoint for Delphi charts.", description="Get charts data.")
@querystring_schema(DelphiChartsV3.RequestSchema)
@response_schema(DelphiChartsV3.ResponseSchema)
async def delphi_charts_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_charts(**data)
    return web.json_response(response)


@docs(
    tags=["charts", "dates"],
    summary="Proxy endpoint for Delphi data-health/chart-positions.",
    description="Get the earliest and the latest available dates per DSP Chart Group.",
)
@querystring_schema(DelphiChartPositionsDatesV3.RequestSchema)
@response_schema(DelphiChartPositionsDatesV3.ResponseSchema)
async def delphi_chart_positions_dates_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_chart_positions_dates(**data)
    return web.json_response(response)


@docs(
    tags=["charts"],
    summary="Proxy endpoint for Delphi /video-positions/charts.",
    description="Get charts videos positions data.",
)
@querystring_schema(DelphiVideoPositionsChartsV3.RequestSchema)
@response_schema(DelphiVideoPositionsChartsV3.ResponseSchema)
async def delphi_video_positions_charts_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_video_positions_charts(**data)
    return web.json_response(response)


@docs(
    tags=["charts"],
    summary="Proxy endpoint for Delphi /video-positions/charts/summary.",
    description="Get charts videos summary data.",
)
@querystring_schema(DelphiVideoPositionsChartsSummaryV3.RequestSchema)
@response_schema(DelphiVideoPositionsChartsSummaryV3.ResponseSchema)
async def delphi_video_positions_charts_summary_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]
    response = await delphi_java_api.get_video_positions_charts_summary(**data)
    return web.json_response(response)


@docs(
    tags=["tiktok"],
    summary="Proxy endpoint for Delphi /tiktok/tracks/analytics.",
    description="Get tiktok tracks analytics data.",
)
@querystring_schema(DelphiTiktokTracksAnalyticsV3.RequestSchema)
@response_schema(DelphiTiktokTracksAnalyticsV3.ResponseSchema)
async def delphi_tiktok_tracks_analytics_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    data = request["querystring"]

    combine_isrc = data.pop("combine_isrc", True)
    if combine_isrc:
        handler = delphi_java_api.get_tiktok_tracks_analytics
    else:
        handler = delphi_java_api.get_tiktok_tracks_analytics_by_isrc
        if data.pop("related_isrcs", True):
            data["expands_list"] = ["related_isrcs"]

    response = await handler(**data)
    return web.json_response(response)


@docs(
    tags=["charts", "apple", "spotify"],
    summary="Proxy endpoint for Delphi /{dsp}/charts/analytics.",
    description="Get chart tracks positions for dates range.",
)
@querystring_schema(DelphiChartsAnalytics.Request)
@response_schema(DelphiChartsAnalytics.Response)
async def delphi_charts_analytics_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    response = await delphi_java_api.get_charts_analytics(**request["querystring"])
    return web.json_response(response)


@docs(
    tags=["charts", "apple", "spotify"],
    summary="Proxy endpoint for Delphi /{dsp}/tracks/charts.",
    description="Get tracks charts metrics.",
)
@querystring_schema(DelphiTracksCharts.Request)
@response_schema(DelphiTracksCharts.Response)
async def delphi_tracks_charts_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    response = await delphi_java_api.get_tracks_charts(**request["querystring"])
    return web.json_response(response)


@docs(
    tags=["playlists", "followers"],
    summary="Proxy endpoint for Delphi public/playlists/followers, add null values for skipped days.",
    description="Get playlist followers, add null values for skipped days.",
)
@querystring_schema(DelphiPlaylistsFollowers.Request)
@response_schema(DelphiPlaylistsFollowers.Response)
async def delphi_playlists_followers_view(request: web.Request) -> web.Response:
    delphi_java_api = request.app["delphi_java_api"]
    response = await delphi_java_api.get_playlists_followers(**request["querystring"])
    return web.json_response(response)