"""Model for sound recording playlist streams."""

import re

from ddtrace import tracer
from oto import response as oto_response

from sound_recordings.connectors import snowflake
from sound_recordings.constants import cache
from sound_recordings.constants.playlists import SPOTIFY_PLAYLISTS
from sound_recordings.constants.store import APPLE_MUSIC_ID
from sound_recordings.utils import format_sql, store_availability
from sound_recordings.utils.cache import cache_in_redis

SOUND_RECORDING_PLAYLIST_FIELDS = [
    "playlist_url",
    "followers",
    "playlist_name",
    "playlist_image",
    "playlist_type_name",
    "store_id",
    "streams",
]

SOUND_RECORDING_PLAYLIST_TOTALS_FIELDS = ["streams"]

SQLLoader = snowflake.SQLLoader(__file__)

spotify_regex = re.compile(r"spotify-personalized-playlist:" r"(?P<playlist_id>.*)")


def _process_playlists(playlists=[]):
    if not playlists:
        return []

    for playlist in playlists:
        match = playlist["playlist_url"] and spotify_regex.match(
            playlist["playlist_url"]
        )
        if match and match["playlist_id"] in SPOTIFY_PLAYLISTS:
            spotify_playlist = SPOTIFY_PLAYLISTS[match["playlist_id"]]
            playlist["playlist_name"] = spotify_playlist["playlist_name"]
            playlist["playlist_image"] = spotify_playlist.get("playlist_image", None)
        elif (
            playlist["playlist_name"] is None
            and playlist["playlist_type_name"] is not None
        ):
            playlist["playlist_name"] = (
                playlist["playlist_type_name"].replace("_", " ").title()
            )

        if (
            playlist["store_id"] == APPLE_MUSIC_ID
            and playlist["playlist_image"] is not None
        ):
            playlist["playlist_image"] = re.sub(
                r"{w}x{h}", "300x300", playlist["playlist_image"]
            )

    return playlists


@tracer.wrap(name="get_playlists")
@cache_in_redis(ttl=cache.SECONDS_PER_HOUR)
def get_playlists(
    permissions_filter,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
    offset=0,
    limit=5,
):
    """Get playlists for a given ISRC by store.

    Args:
        permissions_filter (dict): dict containing resources users can access
        isrc (str): ISRC of track to fetch downloads for.
        distributors (str[]): List of distributors names
        countries(str[]): List of country codes to filter downloads 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:
        list: playlists with streams for sound recording

    """
    if len(store_ids) == 0:
        store_ids = store_availability.get_playlist_store_ids()
    else:
        store_ids = sorted(
            list(
                set(store_ids).intersection(store_availability.get_playlist_store_ids())
            )
        )

    if len(store_ids) == 0:
        return []

    params = {
        **permissions_filter,
        "isrc": isrc,
        "store_ids": store_ids,
        "start_date": start_date,
        "end_date": end_date,
        "distributors": distributors,
        "limit": limit,
        "offset": offset,
    }

    if len(countries) > 0:
        params["country_codes"] = countries
        query_table = "playlists_by_country"
    else:
        query_table = "playlists"

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

    stream_records = snowflake.fetchall(sql, params)

    playlists = [
        dict(zip(SOUND_RECORDING_PLAYLIST_FIELDS, record)) for record in stream_records
    ]

    return oto_response.Response(_process_playlists(playlists))


@tracer.wrap(name="get_total_playlist_streams")
@cache_in_redis(ttl=cache.SECONDS_PER_HOUR)
def get_total_playlist_streams(
    permissions_filter,
    isrc,
    distributors,
    countries=[],
    store_ids=[],
    start_date=None,
    end_date=None,
):
    """Get playlists for a given ISRC by store.

    Args:
        permissions_filter (dict): dict containing resources users can access
        isrc (str): ISRC of track to fetch downloads for.
        distributors (str[]): List of distributors names
        countries(str[]): List of country codes to filter downloads by
        store_ids (list): List of store ids to filter by
        start_date (datetime.date): Start date
        end_date (datetime.date): End date

    Returns:
        int: number of sound recording playlists with streams per store

    """
    if len(store_ids) == 0:
        store_ids = store_availability.get_playlist_store_ids()
    else:
        store_ids = sorted(
            list(
                set(store_ids).intersection(store_availability.get_playlist_store_ids())
            )
        )

    if len(store_ids) == 0:
        return 0

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

    if len(countries) > 0:
        params["country_codes"] = countries
        query_table = "playlist_totals_by_country"
    else:
        query_table = "playlist_totals"

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

    stream_records = snowflake.fetchall(sql, params)

    return oto_response.Response(stream_records[0][0])