"""Model for performance by country."""

from ddtrace import tracer

from sound_recordings.connectors import snowflake
from sound_recordings.constants import cache
from sound_recordings.utils import format_sql, store_availability
from sound_recordings.utils.cache import cache_in_redis

SQLLoader = snowflake.SQLLoader(__file__)


def _get_performance_by_country_result(
    permissions_filter,
    isrc,
    query,
    distributors,
    countries=None,
    store_ids=None,
    start_date=None,
    end_date=None,
):

    params = {
        **permissions_filter,
        "isrc": isrc,
        "distributors": distributors,
        "store_ids": store_ids or [],
        "start_date": start_date,
        "end_date": end_date,
    }

    if countries:
        query = "performance_by_country_filter_by_country"
        params["country_codes"] = countries

    sql = SQLLoader.load_query(query)
    sql = format_sql.format_with_permissions_filter(
        sql, permissions_filter, start_date=start_date, end_date=end_date
    )

    return snowflake.fetchone(sql, params)[0]


@tracer.wrap(name="get_performance_by_country")
@cache_in_redis(ttl=cache.SECONDS_PER_HOUR)
def get_performance_by_country(
    permissions_filter,
    isrc,
    distributors,
    countries=None,
    store_ids=None,
    start_date=None,
    end_date=None,
):
    """Get performance by country payload for given ISRC.

    Args:
        permissions_filter (dict): dict containing resources users can access
        isrc (str): ISRC of track to fetch streams 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:
        List of dictionaries with keys:
            country_code (str): Country code
            date (str): Date in YYYY-MM-DD format
            streams (int): Total streams for date
            streams_with_skips (int): Total streams with skips for date
            saves (int): Total saves for date
            skips (int): Total skips for date

    """
    if not store_ids:
        available_store_ids = store_availability.get_store_ids()
    else:
        available_store_ids = sorted(
            list(set(store_ids).intersection(store_availability.get_store_ids()))
        )

    if not available_store_ids:
        return []

    return _get_performance_by_country_result(
        permissions_filter,
        isrc,
        "performance_by_country",
        distributors,
        countries,
        available_store_ids,
        start_date,
        end_date,
    )