"""Logic for retrieving playlists."""

from ddtrace import tracer
from oto import response as oto_response

from sound_recordings.logic import data_availability, permissions
from sound_recordings.logic.parallel import parallel
from sound_recordings.logic.store_outages import add_outage_error_to_stores
from sound_recordings.models import playlists as playlists_model
from sound_recordings.schemas.playlists import PlaylistsSchema
from sound_recordings.utils import store_availability
from sound_recordings.validation.schema import schema_dump


@tracer.wrap(name="get_playlists")
def get_playlists(
    request_context,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
    offset=0,
    limit=0,
):
    """Return playlists for ISRC for given account type and ID.

    Args:
        request_context (RequestContext): RequestContext class
        isrc (str): ISRC of track to fetch playlists for
        distributors (str[]): List of distributors names
        countries (str[]): List of country codes to filter by
        store_ids (list): List of store ids to filter by
        start_date (datetime.date): Start date
        end_date (datetime.date): End date
        offset (int): Pagination offset
        limit (int): Pagination limit

    Returns:
        oto.response.Response with playlists payload

    """
    # an empty response, but with sources
    response_body = {
        "isrc": isrc,
        "sources": add_outage_error_to_stores(
            store_availability.get_playlist_sources()
        ),
        "playlists": [],
    }

    permissions_filter = permissions.get_permissions_filter(request_context)

    if not (start_date and end_date):
        start_date, end_date = data_availability.get_date_range(
            data_availability.HIGHWATERMARK_DATE, days=28
        )

    requests = {
        "playlists": {
            "func": playlists_model.get_playlists,
            "args": (
                permissions_filter,
                isrc,
                distributors,
                countries,
                store_ids,
                start_date,
                end_date,
                offset,
                limit,
            ),
        },
        "total_playlist_streams": {
            "func": playlists_model.get_total_playlist_streams,
            "args": (
                permissions_filter,
                isrc,
                distributors,
                countries,
                store_ids,
                start_date,
                end_date,
            ),
        },
    }

    result = parallel(requests)

    playlists = result.message["playlists"]

    total_streams = result.message["total_playlist_streams"]
    response_body["total_playlist_streams"] = total_streams

    schema = PlaylistsSchema()
    if playlists:
        response_body["playlists"] = playlists

    return oto_response.Response(schema_dump(schema, response_body))