"""Logic for retrieving downloads."""

from ddtrace import tracer
from oto import response as oto_response

from sound_recordings.logic import data_availability, permissions
from sound_recordings.logic.store_outages import add_outage_error_to_stores
from sound_recordings.models import downloads as downloads_model
from sound_recordings.schemas.downloads import (
    DownloadsAllSchema,
    DownloadsByCountrySchema,
    DownloadsByProductSchema,
    DownloadsByStoreSchema,
    DownloadsSchema,
)
from sound_recordings.utils import date as date_utils
from sound_recordings.utils import downloads as downloads_utils
from sound_recordings.utils import store_availability
from sound_recordings.validation.schema import schema_dump


@tracer.wrap(name="get_downloads_all")
def get_downloads_all(
    request_context,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
):
    """Return downloads all for ISRC for given account type and ID.

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

    Returns:
        oto.response.Response with downloads payload

    """
    # an empty response
    response_body = {"isrc": isrc, "items": []}

    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, downloads=True
        )

    downloads = downloads_model.get_downloads(
        permissions_filter,
        isrc,
        distributors,
        countries,
        store_ids,
        start_date,
        end_date,
    )

    if downloads:
        time_period = date_utils.get_time_period(
            start_date, end_date, data_availability.get_downloads_max_available_date()
        )

        downloads_totals = downloads_utils.get_downloads_totals(downloads, time_period)
        response_body["items"] = downloads_totals

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


@tracer.wrap(name="get_downloads_by_store")
def get_downloads_by_store(
    request_context,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
):
    """Return downloads by store for ISRC for given account type and ID.

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

    Returns:
        oto.response.Response with downloads payload

    """
    # an empty response
    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=28, downloads=True
        )

    downloads = downloads_model.get_downloads(
        permissions_filter,
        isrc,
        distributors,
        countries,
        store_ids,
        start_date,
        end_date,
    )

    if downloads:
        time_period = date_utils.get_time_period(
            start_date, end_date, data_availability.get_downloads_max_available_date()
        )

        downloads_by_store = downloads_utils.get_downloads_by_store(
            downloads, time_period
        )
        response_body["stores"] = downloads_by_store

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


@tracer.wrap(name="get_downloads_by_country")
def get_downloads_by_country(
    request_context,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
):
    """Return downloads by country for ISRC for given account type and ID.

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

    Returns:
        oto.response.Response with downloads payload

    """
    # an empty response
    response_body = {
        "isrc": isrc,
        "countries": [],
    }

    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, downloads=True
        )

    downloads = downloads_model.get_downloads_by_country(
        permissions_filter,
        isrc,
        distributors,
        countries,
        store_ids,
        start_date,
        end_date,
    )

    if downloads:
        time_period = date_utils.get_time_period(
            start_date, end_date, data_availability.get_downloads_max_available_date()
        )

        downloads_by_country = downloads_utils.get_downloads_by_country(
            downloads, time_period
        )
        response_body["countries"] = downloads_by_country

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


@tracer.wrap(name="get_downloads_by_product")
def get_downloads_by_product(
    request_context,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
):
    """Return downloads by product for ISRC for given account type and ID.

    Args:
        request_context (RequestContext): RequestContext class
        isrc (str): ISRC of sound-recording to fetch downloads for
        distributors (list): List of ditributors 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

    Returns:
        oto.response.Response with downloads by product timeseries payload

    """
    # an empty response
    response_body = {"isrc": isrc, "products": []}

    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, downloads=True
        )

    downloads_timeseries = downloads_model.get_downloads_by_product(
        permissions_filter,
        isrc,
        distributors,
        countries,
        store_ids,
        start_date,
        end_date,
    )

    time_period = date_utils.get_time_period(
        start_date, end_date, data_availability.get_downloads_max_available_date()
    )

    downloads_by_product = downloads_utils.get_downloads_by_product(
        downloads_timeseries, time_period
    )

    if downloads_by_product:
        response_body["products"] = downloads_by_product

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


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

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

    Returns:
        oto.response.Response with downloads payload

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

    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, downloads=True
        )

    downloads = downloads_model.get_downloads(
        permissions_filter,
        isrc,
        distributors,
        countries,
        store_ids,
        start_date,
        end_date,
    )

    response_body["aggregate"] = {
        "items": [],
    }

    if downloads:
        time_period = date_utils.get_time_period(
            start_date, end_date, data_availability.get_downloads_max_available_date()
        )

        downloads_by_store = downloads_utils.get_downloads_by_store(
            downloads, time_period
        )

        response_body["stores"] = downloads_by_store if len(store_ids) == 0 else []

        downloads_totals = downloads_utils.get_downloads_totals(downloads, time_period)

        response_body["aggregate"].update({"items": downloads_totals})

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