"""Logic for retrieving streams timeseries by store."""

import oto.response
from ddtrace import tracer

from sound_recordings.logic import data_availability, permissions
from sound_recordings.models import streams_by_store as streams_by_store_model
from sound_recordings.schemas.streams_by_store import StreamsByStoreSchema
from sound_recordings.utils import streams as streams_utils
from sound_recordings.validation.schema import schema_dump


@tracer.wrap(name="get_streams_by_store")
def get_streams_by_store(
    request_context,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
):
    """Return streams by store timeseries for ISRC.

    Args:
        request_context (RequestContext): RequestContext class
        isrc (str): ISRC of track to fetch breakdown for
        distributors (list): List of distributors names
        countries (list): 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

    Returns:
        oto.response.Response with streams by store payload

    """
    response_body = {"isrc": isrc, "stores": []}

    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=7
        )

    streams_timeseries = streams_by_store_model.get_streams_by_store(
        permissions_filter,
        isrc,
        distributors,
        countries,
        store_ids,
        start_date,
        end_date,
    )

    streams_by_store = streams_utils.get_streams_by_store(
        streams_timeseries, start_date, end_date
    )

    if streams_by_store:
        response_body["stores"] = streams_by_store
    schema = StreamsByStoreSchema()
    return oto.response.Response(schema_dump(schema, response_body))